From 106928f91199a6cda5e1cf272067a3c694607dcf Mon Sep 17 00:00:00 2001 From: rajeevgopalakrishna Date: Fri, 10 May 2019 16:09:14 +0530 Subject: [PATCH 001/223] All changes specific to slither-format tool, excluding the dependencies on slither parsing/core and detectors. Single commit because of checking out utils/slither_format from dev-slither-format into this branch. --- utils/slither_format/.gitignore | 1 + utils/slither_format/__init__.py | 0 utils/slither_format/__main__.py | 51 + .../slither_format/format_constable_states.py | 25 + .../format_constant_function.py | 37 + .../format_external_function.py | 59 ++ .../format_naming_convention.py | 578 ++++++++++++ utils/slither_format/format_pragma.py | 69 ++ utils/slither_format/format_solc_version.py | 55 ++ utils/slither_format/format_unused_state.py | 19 + utils/slither_format/slither_format.py | 132 +++ utils/slither_format/tests/.gitignore | 1 + ...F879cb30FE243b4Dfee438691c04_GasToken2.sol | 332 +++++++ ...765f14f10a1a1b08334ef45_StoxSmartToken.sol | 880 ++++++++++++++++++ ...eed7a43e16e3083bc8a4287a_OriginalToken.sol | 241 +++++ ...2b8ed15e9fedaacfcef1fad27_ZilliqaToken.sol | 349 +++++++ utils/slither_format/tests/run_all_tests.py | 17 + .../tests/test_constable_states.py | 57 ++ .../tests/test_constant_function.py | 65 ++ .../tests/test_data/const_state_variables.sol | 52 ++ .../tests/test_data/constant-0.5.1.sol | 18 + .../tests/test_data/constant.sol | 25 + .../tests/test_data/external_function.sol | 101 ++ .../tests/test_data/external_function_2.sol | 55 ++ .../test_data/external_function_import.sol | 7 + .../tests/test_data/naming_convention.sol | 108 +++ .../test_data/naming_convention_contract.sol | 51 + .../test_data/naming_convention_enum.sol | 46 + .../test_data/naming_convention_event.sol | 34 + .../test_data/naming_convention_function.sol | 33 + .../test_data/naming_convention_modifier.sol | 47 + .../test_data/naming_convention_parameter.sol | 47 + .../naming_convention_state_variable.sol | 30 + .../test_data/naming_convention_structure.sol | 51 + .../tests/test_data/pragma.0.4.23.sol | 1 + .../tests/test_data/pragma.0.4.24.sol | 5 + .../tests/test_data/pragma.0.5.2.sol | 1 + .../tests/test_data/pragma.0.5.4.sol | 5 + .../test_data/solc_version_incorrect1.sol | 5 + .../test_data/solc_version_incorrect2.sol | 5 + .../test_data/solc_version_incorrect3.sol | 5 + .../test_data/solc_version_incorrect4.sol | 5 + .../tests/test_data/unused_state.sol | 13 + .../tests/test_external_function.py | 79 ++ .../tests/test_naming_convention.py | 387 ++++++++ utils/slither_format/tests/test_pragma.py | 75 ++ .../slither_format/tests/test_solc_version.py | 118 +++ .../tests/test_unused_state_vars.py | 37 + 48 files changed, 4414 insertions(+) create mode 100644 utils/slither_format/.gitignore create mode 100644 utils/slither_format/__init__.py create mode 100644 utils/slither_format/__main__.py create mode 100644 utils/slither_format/format_constable_states.py create mode 100644 utils/slither_format/format_constant_function.py create mode 100644 utils/slither_format/format_external_function.py create mode 100644 utils/slither_format/format_naming_convention.py create mode 100644 utils/slither_format/format_pragma.py create mode 100644 utils/slither_format/format_solc_version.py create mode 100644 utils/slither_format/format_unused_state.py create mode 100644 utils/slither_format/slither_format.py create mode 100644 utils/slither_format/tests/.gitignore create mode 100644 utils/slither_format/tests/real_world/0x0000000000b3F879cb30FE243b4Dfee438691c04_GasToken2.sol create mode 100644 utils/slither_format/tests/real_world/0x006bea43baa3f7a6f765f14f10a1a1b08334ef45_StoxSmartToken.sol create mode 100644 utils/slither_format/tests/real_world/0x0235fe624e044a05eed7a43e16e3083bc8a4287a_OriginalToken.sol create mode 100644 utils/slither_format/tests/real_world/0x05f4a42e251f2d52b8ed15e9fedaacfcef1fad27_ZilliqaToken.sol create mode 100644 utils/slither_format/tests/run_all_tests.py create mode 100644 utils/slither_format/tests/test_constable_states.py create mode 100644 utils/slither_format/tests/test_constant_function.py create mode 100644 utils/slither_format/tests/test_data/const_state_variables.sol create mode 100644 utils/slither_format/tests/test_data/constant-0.5.1.sol create mode 100644 utils/slither_format/tests/test_data/constant.sol create mode 100644 utils/slither_format/tests/test_data/external_function.sol create mode 100644 utils/slither_format/tests/test_data/external_function_2.sol create mode 100644 utils/slither_format/tests/test_data/external_function_import.sol create mode 100644 utils/slither_format/tests/test_data/naming_convention.sol create mode 100644 utils/slither_format/tests/test_data/naming_convention_contract.sol create mode 100644 utils/slither_format/tests/test_data/naming_convention_enum.sol create mode 100644 utils/slither_format/tests/test_data/naming_convention_event.sol create mode 100644 utils/slither_format/tests/test_data/naming_convention_function.sol create mode 100644 utils/slither_format/tests/test_data/naming_convention_modifier.sol create mode 100644 utils/slither_format/tests/test_data/naming_convention_parameter.sol create mode 100644 utils/slither_format/tests/test_data/naming_convention_state_variable.sol create mode 100644 utils/slither_format/tests/test_data/naming_convention_structure.sol create mode 100644 utils/slither_format/tests/test_data/pragma.0.4.23.sol create mode 100644 utils/slither_format/tests/test_data/pragma.0.4.24.sol create mode 100644 utils/slither_format/tests/test_data/pragma.0.5.2.sol create mode 100644 utils/slither_format/tests/test_data/pragma.0.5.4.sol create mode 100644 utils/slither_format/tests/test_data/solc_version_incorrect1.sol create mode 100644 utils/slither_format/tests/test_data/solc_version_incorrect2.sol create mode 100644 utils/slither_format/tests/test_data/solc_version_incorrect3.sol create mode 100644 utils/slither_format/tests/test_data/solc_version_incorrect4.sol create mode 100644 utils/slither_format/tests/test_data/unused_state.sol create mode 100644 utils/slither_format/tests/test_external_function.py create mode 100644 utils/slither_format/tests/test_naming_convention.py create mode 100644 utils/slither_format/tests/test_pragma.py create mode 100644 utils/slither_format/tests/test_solc_version.py create mode 100644 utils/slither_format/tests/test_unused_state_vars.py diff --git a/utils/slither_format/.gitignore b/utils/slither_format/.gitignore new file mode 100644 index 000000000..c51eb4dee --- /dev/null +++ b/utils/slither_format/.gitignore @@ -0,0 +1 @@ +*.format diff --git a/utils/slither_format/__init__.py b/utils/slither_format/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/utils/slither_format/__main__.py b/utils/slither_format/__main__.py new file mode 100644 index 000000000..a3b0af4f9 --- /dev/null +++ b/utils/slither_format/__main__.py @@ -0,0 +1,51 @@ +import os +import argparse +from slither import Slither +from slither.utils.colors import red +import logging +from .slither_format import slither_format + +logging.basicConfig() +logging.getLogger("Slither").setLevel(logging.INFO) + +available_detectors = ["external-function"] +detectors_to_run = [] + +def parse_args(): + """ + Parse the underlying arguments for the program. + :return: Returns the arguments for the program. + """ + parser = argparse.ArgumentParser(description='slither_format', + usage='slither_format filename') + + parser.add_argument('filename', help='The filename of the contract or truffle directory to analyze.') + parser.add_argument('--solc', help='solc path', default='solc') + parser.add_argument('--verbose', '-v', help='verbose mode output',action='store_true',default=False) + + group_detector = parser.add_argument_group('Detectors') + group_detector.add_argument('--detect', + help='Comma-separated list of detectors, defaults to all, ' + 'available detectors: {}'.format( + ', '.join(d for d in available_detectors)), + action='store', + dest='detectors_to_run', + default='all') + return parser.parse_args() + + +def main(): + # ------------------------------ + # Usage: python3 -m slither_format filename + # Example: python3 -m slither_format contract.sol + # ------------------------------ + # Parse all arguments + args = parse_args() + + # Perform slither analysis on the given filename + slither = Slither(args.filename, is_truffle=os.path.isdir(args.filename), solc=args.solc, disable_solc_warnings=True) + + # Format the input files based on slither analysis + slither_format(args, slither) +if __name__ == '__main__': + main() diff --git a/utils/slither_format/format_constable_states.py b/utils/slither_format/format_constable_states.py new file mode 100644 index 000000000..63b1bc4ed --- /dev/null +++ b/utils/slither_format/format_constable_states.py @@ -0,0 +1,25 @@ +import re + +class FormatConstableStates: + + @staticmethod + def format(slither, patches, elements): + for element in elements: + FormatConstableStates.create_patch(slither, patches, element['source_mapping']['filename'], element['name'], "constant " + element['name'], element['source_mapping']['start'], element['source_mapping']['start'] + element['source_mapping']['length']) + + @staticmethod + def create_patch(slither, patches, in_file, match_text, replace_text, modify_loc_start, modify_loc_end): + in_file_str = slither.source_code[in_file] + old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + (new_str_of_interest, num_repl) = re.subn(match_text, replace_text, old_str_of_interest, 1) + if num_repl != 0: + patches[in_file].append({ + "detector" : "constable-states", + "start" : modify_loc_start, + "end" : modify_loc_end, + "old_string" : old_str_of_interest, + "new_string" : new_str_of_interest + }) + else: + print("Error: State variable not found?!") + sys.exit(-1) diff --git a/utils/slither_format/format_constant_function.py b/utils/slither_format/format_constant_function.py new file mode 100644 index 000000000..15154463a --- /dev/null +++ b/utils/slither_format/format_constant_function.py @@ -0,0 +1,37 @@ +import re + +class FormatConstantFunction: + + @staticmethod + def format(slither, patches, elements): + for element in elements: + if element['type'] != "function": + # Skip variable elements + continue + Found = False + for contract in slither.contracts: + if not Found: + for function in contract.functions: + if contract.name == element['contract']['name'] and function.name == element['name']: + FormatConstantFunction.create_patch(slither, patches, element['source_mapping']['filename'], ["view","pure","constant"], "", int(function.parameters_src.split(':')[0]), int(function.returns_src.split(':')[0])) + Found = True + + @staticmethod + def create_patch(slither, patches, in_file, match_text, replace_text, modify_loc_start, modify_loc_end): + in_file_str = slither.source_code[in_file] + old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + for match_text_item in match_text: + (new_str_of_interest, num_repl) = re.subn(match_text_item, replace_text, old_str_of_interest, 1) + if num_repl != 0: + break + if num_repl != 0: + patches[in_file].append({ + "detector" : "constant-function", + "start" : modify_loc_start, + "end" : modify_loc_end, + "old_string" : old_str_of_interest, + "new_string" : new_str_of_interest + }) + else: + print("Error: No view/pure/constant specifier exists. Regex failed to remove specifier!") + sys.exit(-1) diff --git a/utils/slither_format/format_external_function.py b/utils/slither_format/format_external_function.py new file mode 100644 index 000000000..57793aa7d --- /dev/null +++ b/utils/slither_format/format_external_function.py @@ -0,0 +1,59 @@ +import re + +class FormatExternalFunction: + + @staticmethod + def format (slither, patches, elements): + for element in elements: + Found = False + for contract in slither.contracts: + if not Found and contract.name == element['contract']['name']: + for function in contract.functions: + if function.name == element['name']: + # If function parameters are written to in function body then we cannot convert this function + # to external because external function parameters are allocated in calldata region which is + # non-modifiable. See https://solidity.readthedocs.io/en/develop/types.html#data-location + if not FormatExternalFunction.function_parameters_written(function): + FormatExternalFunction.create_patch(slither, patches, element['source_mapping']['filename'], "public", "external", int(function.parameters_src.split(':')[0]), int(function.returns_src.split(':')[0])) + Found = True + break + + @staticmethod + def create_patch(slither, patches, in_file, match_text, replace_text, modify_loc_start, modify_loc_end): + in_file_str = slither.source_code[in_file] + old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + old_str_of_interest_beyond_parameters = ')'.join(old_str_of_interest.split(')')[1:]) + s = old_str_of_interest_beyond_parameters.split('(') + if len(s) == 1: + account_for_return = 0 + else: + account_for_return = 1 + old_str_of_interest_beyond_parameters_before_modifier_return = old_str_of_interest_beyond_parameters.split('(')[0] + m = re.search("public", old_str_of_interest_beyond_parameters_before_modifier_return) + if m is None: + # No visibility specifier exists; public by default. + (new_str_of_interest, _) = re.subn(" ", " external ", old_str_of_interest_beyond_parameters_before_modifier_return, 1) + patches[in_file].append({ + "detector" : "external-function", + "start" : modify_loc_start + len(old_str_of_interest.split(')')[0]) + 1, + "end" : modify_loc_end - len('('.join(old_str_of_interest_beyond_parameters.split('(')[1:])) - account_for_return, + "old_string" : old_str_of_interest_beyond_parameters_before_modifier_return, + "new_string" : new_str_of_interest + }) + else: + (new_str_of_interest, _) = re.subn(match_text, replace_text, old_str_of_interest_beyond_parameters_before_modifier_return, 1) + patches[in_file].append({ + "detector" : "external-function", + "start" : modify_loc_start + len(old_str_of_interest.split(')')[0]) + 1 + m.span()[0], + "end" : modify_loc_end - len('('.join(old_str_of_interest_beyond_parameters.split('(')[1:])) - account_for_return, + "old_string" : old_str_of_interest_beyond_parameters_before_modifier_return, + "new_string" : new_str_of_interest + }) + + @staticmethod + def function_parameters_written(function): + for node in function.nodes: + if any (var.name == parameter.name for var in node.local_variables_written for parameter in function.parameters): + return True + return False + diff --git a/utils/slither_format/format_naming_convention.py b/utils/slither_format/format_naming_convention.py new file mode 100644 index 000000000..5a60a2a46 --- /dev/null +++ b/utils/slither_format/format_naming_convention.py @@ -0,0 +1,578 @@ +import re, sys +from slither.core.expressions.identifier import Identifier +from slither.core.cfg.node import Node +from slither.slithir.operations import NewContract +from slither.slithir.operations import Member + +class FormatNamingConvention: + + @staticmethod + def format(slither, patches, elements): + for element in elements: + if (element['target'] == "parameter"): + FormatNamingConvention.create_patch(slither, patches, element['target'], element['name'], element['function'], element['contract'], element['source_mapping']['filename'],element['source_mapping']['start'],(element['source_mapping']['start']+element['source_mapping']['length'])) + elif (element['target'] == "modifier" or element['target'] == "function" or element['target'] == "event" or element['target'] == "variable" or element['target'] == "variable_constant" or element['target'] == "enum" or element['target'] == "structure"): + FormatNamingConvention.create_patch(slither, patches, element['target'], element['name'], element['name'], element['contract'], element['source_mapping']['filename'],element['source_mapping']['start'],(element['source_mapping']['start']+element['source_mapping']['length'])) + else: + FormatNamingConvention.create_patch(slither, patches, element['target'], element['name'], element['name'], element['name'], element['source_mapping']['filename'],element['source_mapping']['start'],(element['source_mapping']['start']+element['source_mapping']['length'])) + + @staticmethod + def create_patch(slither, patches, _target, name, function_name, contract_name, in_file, modify_loc_start, modify_loc_end): + if _target == "contract": + FormatNamingConvention.create_patch_contract_definition(slither, patches, name, in_file, modify_loc_start, modify_loc_end) + FormatNamingConvention.create_patch_contract_uses(slither, patches, name, in_file) + elif _target == "structure": + FormatNamingConvention.create_patch_struct_definition(slither, patches, name, contract_name, in_file, modify_loc_start, modify_loc_end) + FormatNamingConvention.create_patch_struct_uses(slither, patches, name, contract_name, in_file) + elif _target == "event": + FormatNamingConvention.create_patch_event_definition(slither, patches, name, contract_name, in_file, modify_loc_start, modify_loc_end) + FormatNamingConvention.create_patch_event_calls(slither, patches, name, contract_name, in_file) + elif _target == "function": + if name != contract_name: + FormatNamingConvention.create_patch_function_definition(slither, patches, name, contract_name, in_file, modify_loc_start, modify_loc_end) + FormatNamingConvention.create_patch_function_calls(slither, patches, name, contract_name, in_file) + elif _target == "parameter": + FormatNamingConvention.create_patch_parameter_declaration(slither, patches, name, function_name, contract_name, in_file, modify_loc_start, modify_loc_end) + FormatNamingConvention.create_patch_parameter_uses(slither, patches, name, function_name, contract_name, in_file) + elif _target == "variable_constant" or _target == "variable": + FormatNamingConvention.create_patch_state_variable_declaration(slither, patches, _target, name, contract_name, in_file, modify_loc_start, modify_loc_end) + FormatNamingConvention.create_patch_state_variable_uses(slither, patches, _target, name, contract_name, in_file) + elif _target == "enum": + FormatNamingConvention.create_patch_enum_definition(slither, patches, name, contract_name, in_file, modify_loc_start, modify_loc_end) + FormatNamingConvention.create_patch_enum_uses(slither, patches, name, contract_name, in_file) + elif _target == "modifier": + FormatNamingConvention.create_patch_modifier_definition(slither, patches, name, contract_name, in_file, modify_loc_start, modify_loc_end) + FormatNamingConvention.create_patch_modifier_uses(slither, patches, name, contract_name, in_file) + else: + print("Unknown naming convention! " + _target) + sys.exit(-1) + + @staticmethod + def create_patch_contract_definition(slither, patches, name, in_file, modify_loc_start, modify_loc_end): + for contract in slither.contracts: + if contract.name == name: + in_file_str = slither.source_code[in_file] + old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + m = re.match(r'(.*)'+"contract"+r'(.*)'+name, old_str_of_interest) + old_str_of_interest = in_file_str[modify_loc_start:modify_loc_start+m.span()[1]] + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"contract"+r'(.*)'+name, r'\1'+"contract"+r'\2'+name.capitalize(), old_str_of_interest, 1) + if num_repl != 0: + patch = { + "detector" : "naming-convention (contract definition)", + "start":modify_loc_start, + "end":modify_loc_start+m.span()[1], + "old_string":old_str_of_interest, + "new_string":new_str_of_interest + } + if not patch in patches[in_file]: + patches[in_file].append(patch) + else: + print("Error: Could not find contract?!") + sys.exit(-1) + + @staticmethod + def create_patch_contract_uses(slither, patches, name, in_file): + for contract in slither.contracts: + if contract.name != name: + in_file_str = slither.source_code[in_file] + # Check state variables of contract type + # To-do: Deep-check aggregate types (struct and mapping) + svs = contract.variables + for sv in svs: + if (str(sv.type) == name): + old_str_of_interest = in_file_str[contract.get_source_var_declaration(sv.name)['start']:(contract.get_source_var_declaration(sv.name)['start']+contract.get_source_var_declaration(sv.name)['length'])] + (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(),old_str_of_interest, 1) + patch = { + "detector" : "naming-convention (contract state variable)", + "start" : contract.get_source_var_declaration(sv.name)['start'], + "end" : contract.get_source_var_declaration(sv.name)['start'] + contract.get_source_var_declaration(sv.name)['length'], + "old_string" : old_str_of_interest, + "new_string" : new_str_of_interest + } + if not patch in patches[in_file]: + patches[in_file].append(patch) + # Check function+modifier locals+parameters+returns + # To-do: Deep-check aggregate types (struct and mapping) + fms = contract.functions + contract.modifiers + for fm in fms: + for v in fm.variables: + if (str(v.type) == name): + old_str_of_interest = in_file_str[fm.get_source_var_declaration(v.name)['start']:(fm.get_source_var_declaration(v.name)['start']+fm.get_source_var_declaration(v.name)['length'])] + (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(),old_str_of_interest, 1) + patch = { + "detector" : "naming-convention (contract function variable)", + "start" : fm.get_source_var_declaration(v.name)['start'], + "end" : fm.get_source_var_declaration(v.name)['start'] + fm.get_source_var_declaration(v.name)['length'], + "old_string" : old_str_of_interest, + "new_string" : new_str_of_interest + } + if not patch in patches[in_file]: + patches[in_file].append(patch) + # Check "new" expressions for creation of contract objects + for function in contract.functions: + for node in function.nodes: + for ir in node.irs: + if isinstance(ir, NewContract) and ir.contract_name == name: + old_str_of_interest = in_file_str[node.source_mapping['start']:node.source_mapping['start'] + node.source_mapping['length']] + m = re.search("new"+r'(.*)'+name, old_str_of_interest) + old_str_of_interest = old_str_of_interest[m.span()[0]:] + (new_str_of_interest, num_repl) = re.subn("new"+r'(.*)'+name, "new"+r'\1'+name[0].upper()+name[1:], old_str_of_interest, 1) + if num_repl != 0: + patch = { + "detector" : "naming-convention (contract new object)", + "start" : node.source_mapping['start'] + m.span()[0], + "end" : node.source_mapping['start'] + m.span()[1], + "old_string" : old_str_of_interest, + "new_string" : new_str_of_interest + } + if not patch in patches[in_file]: + patches[in_file].append(patch) + else: + print("Error: Could not find new object?!") + sys.exit(-1) + + else: + # Ignore contract definition + continue + + @staticmethod + def create_patch_modifier_definition(slither, patches, name, contract_name, in_file, modify_loc_start, modify_loc_end): + for contract in slither.contracts: + if contract.name == contract_name: + for modifier in contract.modifiers: + if modifier.name == name: + in_file_str = slither.source_code[in_file] + old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + m = re.match(r'(.*)'+"modifier"+r'(.*)'+name, old_str_of_interest) + old_str_of_interest = in_file_str[modify_loc_start:modify_loc_start+m.span()[1]] + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"modifier"+r'(.*)'+name, r'\1'+"modifier"+r'\2'+name[0].lower()+name[1:], old_str_of_interest, 1) + if num_repl != 0: + patch = { + "detector" : "naming-convention (modifier definition)", + "start" : modify_loc_start, + "end" : modify_loc_start+m.span()[1], + "old_string" : old_str_of_interest, + "new_string" : new_str_of_interest + } + if not patch in patches[in_file]: + patches[in_file].append(patch) + else: + print("Error: Could not find modifier?!") + sys.exit(-1) + + @staticmethod + def create_patch_modifier_uses(slither, patches, name, contract_name, in_file): + for contract in slither.contracts: + if contract.name == contract_name: + for function in contract.functions: + for m in function.modifiers: + if (m.name == name): + in_file_str = slither.source_code[in_file] + old_str_of_interest = in_file_str[int(function.parameters_src.split(':')[0]):int(function.returns_src.split(':')[0])] + (new_str_of_interest, num_repl) = re.subn(name, name[0].lower()+name[1:],old_str_of_interest,1) + if num_repl != 0: + patch = { + "detector" : "naming-convention (modifier uses)", + "start" : int(function.parameters_src.split(':')[0]), + "end" : int(function.returns_src.split(':')[0]), + "old_string" : old_str_of_interest, + "new_string" : new_str_of_interest + } + if not patch in patches[in_file]: + patches[in_file].append(patch) + else: + print("Error: Could not find modifier name?!") + sys.exit(-1) + + @staticmethod + def create_patch_function_definition(slither, patches, name, contract_name, in_file, modify_loc_start, modify_loc_end): + for contract in slither.contracts: + if contract.name == contract_name: + for function in contract.functions: + if function.name == name: + in_file_str = slither.source_code[in_file] + old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + m = re.match(r'(.*)'+"function"+r'(.*)'+name, old_str_of_interest) + old_str_of_interest = in_file_str[modify_loc_start:modify_loc_start+m.span()[1]] + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"function"+r'(.*)'+name, r'\1'+"function"+r'\2'+name[0].lower()+name[1:], old_str_of_interest, 1) + if num_repl != 0: + patch = { + "detector" : "naming-convention (function definition)", + "start" : modify_loc_start, + "end" : modify_loc_start+m.span()[1], + "old_string" : old_str_of_interest, + "new_string" : new_str_of_interest + } + if not patch in patches[in_file]: + patches[in_file].append(patch) + else: + print("Error: Could not find function?!") + sys.exit(-1) + + @staticmethod + def create_patch_function_calls(slither, patches, name, contract_name, in_file): + for contract in slither.contracts: + for function in contract.functions: + for node in function.nodes: + for high_level_call in node.high_level_calls: + if (high_level_call[0].name == contract_name and high_level_call[1].name == name): + for external_call in node.external_calls_as_expressions: + called_function = str(external_call.called).split('.')[-1] + if called_function == high_level_call[1].name: + in_file_str = slither.source_code[in_file] + old_str_of_interest = in_file_str[int(external_call.source_mapping['start']):int(external_call.source_mapping['start'])+int(external_call.source_mapping['length'])] + called_function_name = old_str_of_interest.split('.')[-1] + fixed_function_name = called_function_name[0].lower() + called_function_name[1:] + new_string = '.'.join(old_str_of_interest.split('.')[:-1]) + '.' + fixed_function_name + patch = { + "detector" : "naming-convention (function calls)", + "start" : external_call.source_mapping['start'], + "end" : int(external_call.source_mapping['start']) + int(external_call.source_mapping['length']), + "old_string" : old_str_of_interest, + "new_string" : new_string + } + if not patch in patches[in_file]: + patches[in_file].append(patch) + for internal_call in node.internal_calls_as_expressions: + if (str(internal_call.called) == name): + in_file_str = slither.source_code[in_file] + old_str_of_interest = in_file_str[int(internal_call.source_mapping['start']):int(internal_call.source_mapping['start'])+int(internal_call.source_mapping['length'])] + patch = { + "detector" : "naming-convention (function calls)", + "start" : internal_call.source_mapping['start'], + "end" : int(internal_call.source_mapping['start']) + int(internal_call.source_mapping['length']), + "old_string" : old_str_of_interest, + "new_string" : old_str_of_interest[0].lower()+old_str_of_interest[1:] + } + if not patch in patches[in_file]: + patches[in_file].append(patch) + + @staticmethod + def create_patch_event_definition(slither, patches, name, contract_name, in_file, modify_loc_start, modify_loc_end): + for contract in slither.contracts: + if contract.name == contract_name: + for event in contract.events: + if event.full_name == name: + event_name = name.split('(')[0] + in_file_str = slither.source_code[in_file] + old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"event"+r'(.*)'+event_name, r'\1'+"event"+r'\2'+event_name[0].capitalize()+event_name[1:], old_str_of_interest, 1) + if num_repl != 0: + patch = { + "detector" : "naming-convention (event definition)", + "start" : modify_loc_start, + "end" : modify_loc_end, + "old_string" : old_str_of_interest, + "new_string" : new_str_of_interest + } + if not patch in patches[in_file]: + patches[in_file].append(patch) + else: + print("Error: Could not find event?!") + sys.exit(-1) + + @staticmethod + def create_patch_event_calls(slither, patches, name, contract_name, in_file): + event_name = name.split('(')[0] + for contract in slither.contracts: + if (contract.name == contract_name): + for function in contract.functions: + for node in function.nodes: + for call in node.internal_calls_as_expressions: + if (str(call.called) == event_name): + in_file_str = slither.source_code[in_file] + old_str_of_interest = in_file_str[int(call.source_mapping['start']):int(call.source_mapping['start'])+int(call.source_mapping['length'])] + patch = { + "detector" : "naming-convention (event calls)", + "start" : call.source_mapping['start'], + "end" : int(call.source_mapping['start']) + int(call.source_mapping['length']), + "old_string" : old_str_of_interest, + "new_string" : old_str_of_interest[0].capitalize()+old_str_of_interest[1:] + } + if not patch in patches[in_file]: + patches[in_file].append(patch) + + @staticmethod + def create_patch_parameter_declaration(slither, patches, name, function_name, contract_name, in_file, modify_loc_start, modify_loc_end): + for contract in slither.contracts: + if contract.name == contract_name: + for function in contract.functions: + if function.name == function_name: + in_file_str = slither.source_code[in_file] + old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + if(name[0] == '_'): + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+name[0]+name[1].upper()+name[2:]+r'\2', old_str_of_interest, 1) + else: + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+'_'+name[0].upper()+name[1:]+r'\2', old_str_of_interest, 1) + if num_repl != 0: + patch = { + "detector" : "naming-convention (parameter declaration)", + "start" : modify_loc_start, + "end" : modify_loc_end, + "old_string" : old_str_of_interest, + "new_string" : new_str_of_interest + } + if not patch in patches[in_file]: + patches[in_file].append(patch) + else: + print("Error: Could not find parameter?!") + sys.exit(-1) + + @staticmethod + def create_patch_parameter_uses(slither, patches, name, function_name, contract_name, in_file): + for contract in slither.contracts: + if (contract.name == contract_name): + for function in contract.functions: + if (function.name == function_name): + in_file_str = slither.source_code[in_file] + for node in function.nodes: + vars = node._expression_vars_written + node._expression_vars_read + for v in vars: + if isinstance(v, Identifier) and str(v) == name and [str(lv) for lv in (node._local_vars_read+node._local_vars_written) if str(lv) == name]: + modify_loc_start = int(v.source_mapping['start']) + modify_loc_end = int(v.source_mapping['start']) + int(v.source_mapping['length']) + old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + if(name[0] == '_'): + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+name[0]+name[1].upper()+name[2:]+r'\2', old_str_of_interest, 1) + else: + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+'_'+name[0].upper()+name[1:]+r'\2', old_str_of_interest, 1) + if num_repl != 0: + patch = { + "detector" : "naming-convention (parameter uses)", + "start" : modify_loc_start, + "end" : modify_loc_end, + "old_string" : old_str_of_interest, + "new_string" : new_str_of_interest + } + if not patch in patches[in_file]: + patches[in_file].append(patch) + else: + print("Error: Could not find parameter?!") + sys.exit(-1) + # Process function parameters passed to modifiers + for modifier in function._expression_modifiers: + for arg in modifier.arguments: + if str(arg) == name: + old_str_of_interest = in_file_str[modifier.source_mapping['start']:modifier.source_mapping['start']+modifier.source_mapping['length']] + old_str_of_interest_beyond_modifier_name = old_str_of_interest.split('(')[1] + if(name[0] == '_'): + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+name[0]+name[1].upper()+name[2:]+r'\2', old_str_of_interest_beyond_modifier_name, 1) + else: + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+'_'+name[0].upper()+name[1:]+r'\2', old_str_of_interest_beyond_modifier_name, 1) + if num_repl != 0: + patch = { + "detector" : "naming-convention (parameter uses)", + "start" : modifier.source_mapping['start'] + len(old_str_of_interest.split('(')[0]) + 1, + "end" : modifier.source_mapping['start'] + modifier.source_mapping['length'], + "old_string" : old_str_of_interest_beyond_modifier_name, + "new_string" : new_str_of_interest + } + if not patch in patches[in_file]: + patches[in_file].append(patch) + else: + print("Error: Could not find parameter?!") + sys.exit(-1) + + @staticmethod + def create_patch_state_variable_declaration(slither, patches, _target, name, contract_name, in_file, modify_loc_start, modify_loc_end): + for contract in slither.contracts: + if (contract.name == contract_name): + for var in contract.state_variables: + if (var.name == name): + in_file_str = slither.source_code[in_file] + old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + m = re.search(name, old_str_of_interest) + if (_target == "variable_constant"): + new_string = old_str_of_interest[m.span()[0]:m.span()[1]].upper() + else: + new_string = old_str_of_interest[m.span()[0]:m.span()[1]] + new_string = new_string[0].lower()+new_string[1:] + patch = { + "detector" : "naming-convention (state variable declaration)", + "start" : modify_loc_start+m.span()[0], + "end" : modify_loc_start+m.span()[1], + "old_string" : old_str_of_interest[m.span()[0]:m.span()[1]], + "new_string" : new_string + } + if not patch in patches[in_file]: + patches[in_file].append(patch) + + @staticmethod + def create_patch_state_variable_uses(slither, patches, _target, name, contract_name, in_file): + # To-do: Check cross-contract state variable uses + for contract in slither.contracts: + if (contract.name == contract_name): + fms = contract.functions + contract.modifiers + for fm in fms: + for node in fm.nodes: + vars = node._expression_vars_written + node._expression_vars_read + for v in vars: + if isinstance(v, Identifier) and str(v) == name and [str(sv) for sv in (node._state_vars_read+node._state_vars_written) if str(sv) == name]: + modify_loc_start = int(v.source_mapping['start']) + modify_loc_end = int(v.source_mapping['start']) + int(v.source_mapping['length']) + in_file_str = slither.source_code[in_file] + old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + if (_target == "variable_constant"): + new_str_of_interest = old_str_of_interest.upper() + else: + new_str_of_interest = old_str_of_interest + new_str_of_interest = new_str_of_interest[0].lower()+new_str_of_interest[1:] + patch = { + "detector" : "naming-convention (state variable uses)", + "start" : modify_loc_start, + "end" : modify_loc_end, + "old_string" : old_str_of_interest, + "new_string" : new_str_of_interest + } + if not patch in patches[in_file]: + patches[in_file].append(patch) + + @staticmethod + def create_patch_enum_definition(slither, patches, name, contract_name, in_file, modify_loc_start, modify_loc_end): + for contract in slither.contracts: + if (contract.name == contract_name): + for enum in contract.enums: + if (enum.name == name): + in_file_str = slither.source_code[in_file] + old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"enum"+r'(.*)'+name, r'\1'+"enum"+r'\2'+name[0].capitalize()+name[1:], old_str_of_interest, 1) + if num_repl != 0: + patch = { + "detector" : "naming-convention (enum definition)", + "start" : modify_loc_start, + "end" : modify_loc_end, + "old_string" : old_str_of_interest, + "new_string" : new_str_of_interest + } + if not patch in patches[in_file]: + patches[in_file].append(patch) + else: + print("Error: Could not find enum?!") + sys.exit(-1) + + @staticmethod + def create_patch_enum_uses(slither, patches, name, contract_name, in_file): + for contract in slither.contracts: + if contract.name == contract_name: + in_file_str = slither.source_code[in_file] + # Check state variable declarations of enum type + # To-do: Deep-check aggregate types (struct and mapping) + svs = contract.variables + for sv in svs: + if (str(sv.type) == contract_name + "." + name): + old_str_of_interest = in_file_str[contract.get_source_var_declaration(sv.name)['start']:(contract.get_source_var_declaration(sv.name)['start']+contract.get_source_var_declaration(sv.name)['length'])] + (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(),old_str_of_interest, 1) + patch = { + "detector" : "naming-convention (enum use)", + "start" : contract.get_source_var_declaration(sv.name)['start'], + "end" : contract.get_source_var_declaration(sv.name)['start'] + contract.get_source_var_declaration(sv.name)['length'], + "old_string" : old_str_of_interest, + "new_string" : new_str_of_interest + } + if not patch in patches[in_file]: + patches[in_file].append(patch) + # Check function+modifier locals+parameters+returns + # To-do: Deep-check aggregate types (struct and mapping) + fms = contract.functions + contract.modifiers + for fm in fms: + # Enum declarations + for v in fm.variables: + if (str(v.type) == contract_name + "." + name): + old_str_of_interest = in_file_str[fm.get_source_var_declaration(v.name)['start']:(fm.get_source_var_declaration(v.name)['start']+fm.get_source_var_declaration(v.name)['length'])] + (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(),old_str_of_interest, 1) + patch = { + "detector" : "naming-convention (enum use)", + "start" : fm.get_source_var_declaration(v.name)['start'], + "end" : fm.get_source_var_declaration(v.name)['start'] + fm.get_source_var_declaration(v.name)['length'], + "old_string" : old_str_of_interest, + "new_string" : new_str_of_interest + } + if not patch in patches[in_file]: + patches[in_file].append(patch) + # Capture enum uses such as "num = numbers.ONE;" + for function in contract.functions: + for node in function.nodes: + for ir in node.irs: + if isinstance(ir, Member): + if str(ir.variable_left) == name: + old_str_of_interest = in_file_str[node.source_mapping['start']:(node.source_mapping['start']+node.source_mapping['length'])].split('=')[1] + m = re.search(r'(.*)'+name, old_str_of_interest) + old_str_of_interest = old_str_of_interest[m.span()[0]:] + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name, r'\1'+name[0].upper()+name[1:], old_str_of_interest, 1) + if num_repl != 0: + patch = { + "detector" : "naming-convention (enum use)", + "start" : node.source_mapping['start'] + len(in_file_str[node.source_mapping['start']:(node.source_mapping['start']+node.source_mapping['length'])].split('=')[0]) + 1 + m.span()[0], + "end" : node.source_mapping['start'] + len(in_file_str[node.source_mapping['star\ +t']:(node.source_mapping['start']+node.source_mapping['length'])].split('=')[0]) + 1 + m.span()[0] + len(old_str_of_interest), + "old_string" : old_str_of_interest, + "new_string" : new_str_of_interest + } + if not patch in patches[in_file]: + patches[in_file].append(patch) + else: + print("Error: Could not find new object?!") + sys.exit(-1) + # To-do: Check any other place/way where enum type is used + + @staticmethod + def create_patch_struct_definition(slither, patches, name, contract_name, in_file, modify_loc_start, modify_loc_end): + for contract in slither.contracts: + if (contract.name == contract_name): + for struct in contract.structures: + if (struct.name == name): + in_file_str = slither.source_code[in_file] + old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"struct"+r'(.*)'+name, r'\1'+"struct"+r'\2'+name[0].capitalize()+name[1:], old_str_of_interest, 1) + if num_repl != 0: + patch = { + "detector" : "naming-convention (struct definition)", + "start" : modify_loc_start, + "end" : modify_loc_end, + "old_string" : old_str_of_interest, + "new_string" : new_str_of_interest + } + if not patch in patches[in_file]: + patches[in_file].append(patch) + else: + print("Error: Could not find struct?!") + sys.exit(-1) + + @staticmethod + def create_patch_struct_uses(slither, patches, name, contract_name, in_file): + for contract in slither.contracts: + in_file_str = slither.source_code[in_file] + # Check state variables of struct type + # To-do: Deep-check aggregate types (struct and mapping) + svs = contract.variables + for sv in svs: + if (str(sv.type) == contract_name + "." + name): + old_str_of_interest = in_file_str[contract.get_source_var_declaration(sv.name)['start']:(contract.get_source_var_declaration(sv.name)['start']+contract.get_source_var_declaration(sv.name)['length'])] + (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(),old_str_of_interest, 1) + patch = { + "detector" : "naming-convention (struct use)", + "start" : contract.get_source_var_declaration(sv.name)['start'], + "end" : contract.get_source_var_declaration(sv.name)['start'] + contract.get_source_var_declaration(sv.name)['length'], + "old_string" : old_str_of_interest, + "new_string" : new_str_of_interest + } + if not patch in patches[in_file]: + patches[in_file].append(patch) + # Check function+modifier locals+parameters+returns + # To-do: Deep-check aggregate types (struct and mapping) + fms = contract.functions + contract.modifiers + for fm in fms: + for v in fm.variables: + if (str(v.type) == contract_name + "." + name): + old_str_of_interest = in_file_str[fm.get_source_var_declaration(v.name)['start']:(fm.get_source_var_declaration(v.name)['start']+fm.get_source_var_declaration(v.name)['length'])] + (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(),old_str_of_interest, 1) + patch = { + "detector" : "naming-convention (struct use)", + "start" : fm.get_source_var_declaration(v.name)['start'], + "end" : fm.get_source_var_declaration(v.name)['start'] + fm.get_source_var_declaration(v.name)['length'], + "old_string" : old_str_of_interest, + "new_string" : new_str_of_interest + } + if not patch in patches[in_file]: + patches[in_file].append(patch) + # To-do: Check any other place/way where struct type is used (e.g. typecast) diff --git a/utils/slither_format/format_pragma.py b/utils/slither_format/format_pragma.py new file mode 100644 index 000000000..f3f06a667 --- /dev/null +++ b/utils/slither_format/format_pragma.py @@ -0,0 +1,69 @@ +import re + +class FormatPragma: + + # Indicates the recommended versions for replacement + REPLACEMENT_VERSIONS = ["0.4.25", "0.5.3"] + + # group: + # 0: ^ > >= < <= (optional) + # 1: ' ' (optional) + # 2: version number + # 3: version number + # 4: version number + PATTERN = re.compile('(\^|>|>=|<|<=)?([ ]+)?(\d+)\.(\d+)\.(\d+)') + + @staticmethod + def format(slither, patches, elements): + versions_used = [] + for element in elements: + versions_used.append(element['expression']) + solc_version_replace = FormatPragma.analyse_versions(versions_used) + for element in elements: + FormatPragma.create_patch(slither, patches, element['source_mapping']['filename'], solc_version_replace, element['source_mapping']['start'], element['source_mapping']['start'] + element['source_mapping']['length']) + + @staticmethod + def analyse_versions(used_solc_versions): + replace_solc_versions = list() + for version in used_solc_versions: + replace_solc_versions.append(FormatPragma.determine_solc_version_replacement(version)) + if not all(version == replace_solc_versions[0] for version in replace_solc_versions): + print("Multiple incompatible versions!") + sys.exit(-1) + else: + return replace_solc_versions[0] + + @staticmethod + def determine_solc_version_replacement(used_solc_version): + versions = FormatPragma.PATTERN.findall(used_solc_version) + if len(versions) == 1: + version = versions[0] + minor_version = '.'.join(version[2:])[2] + if minor_version == '4': + return "pragma solidity " + FormatPragma.REPLACEMENT_VERSIONS[0] + ';' + elif minor_version == '5': + return "pragma solidity " + FormatPragma.REPLACEMENT_VERSIONS[1] + ';' + else: + print("Unknown version!") + sys.exit(-1) + elif len(versions) == 2: + version_left = versions[0] + version_right = versions[1] + minor_version_left = '.'.join(version_left[2:])[2] + minor_version_right = '.'.join(version_right[2:])[2] + if minor_version_right == '4': + return "pragma solidity " + FormatPragma.REPLACEMENT_VERSIONS[0] + ';' + elif minor_version_right in ['5','6']: + return "pragma solidity " + FormatPragma.REPLACEMENT_VERSIONS[1] + ';' + + @staticmethod + def create_patch(slither, patches, in_file, pragma, modify_loc_start, modify_loc_end): + in_file_str = slither.source_code[in_file] + old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + patches[in_file].append({ + "detector" : "pragma", + "start" : modify_loc_start, + "end" : modify_loc_end, + "old_string" : old_str_of_interest, + "new_string" : pragma + }) diff --git a/utils/slither_format/format_solc_version.py b/utils/slither_format/format_solc_version.py new file mode 100644 index 000000000..687d62b7c --- /dev/null +++ b/utils/slither_format/format_solc_version.py @@ -0,0 +1,55 @@ +import re + +class FormatSolcVersion: + + # Indicates the recommended versions for replacement + REPLACEMENT_VERSIONS = ["0.4.25", "0.5.3"] + + # group: + # 0: ^ > >= < <= (optional) + # 1: ' ' (optional) + # 2: version number + # 3: version number + # 4: version number + PATTERN = re.compile('(\^|>|>=|<|<=)?([ ]+)?(\d+)\.(\d+)\.(\d+)') + + @staticmethod + def format(slither, patches, elements): + for element in elements: + solc_version_replace = FormatSolcVersion.determine_solc_version_replacement(element['expression']) + FormatSolcVersion.create_patch(slither, patches, element['source_mapping']['filename'], solc_version_replace, element['source_mapping']['start'], element['source_mapping']['start'] + element['source_mapping']['length']) + + @staticmethod + def determine_solc_version_replacement(used_solc_version): + versions = FormatSolcVersion.PATTERN.findall(used_solc_version) + if len(versions) == 1: + version = versions[0] + minor_version = '.'.join(version[2:])[2] + if minor_version == '4': + return "pragma solidity " + FormatSolcVersion.REPLACEMENT_VERSIONS[0] + ';' + elif minor_version == '5': + return "pragma solidity " + FormatSolcVersion.REPLACEMENT_VERSIONS[1] + ';' + else: + print("Unknown version!") + sys.exit(-1) + elif len(versions) == 2: + version_left = versions[0] + version_right = versions[1] + minor_version_left = '.'.join(version_left[2:])[2] + minor_version_right = '.'.join(version_right[2:])[2] + if minor_version_right == '4': + return "pragma solidity " + FormatSolcVersion.REPLACEMENT_VERSIONS[0] + ';' + elif minor_version_right in ['5','6']: + return "pragma solidity " + FormatSolcVersion.REPLACEMENT_VERSIONS[1] + ';' + + @staticmethod + def create_patch(slither, patches, in_file, solc_version, modify_loc_start, modify_loc_end): + in_file_str = slither.source_code[in_file] + old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + patches[in_file].append({ + "detector" : "solc-version", + "start" : modify_loc_start, + "end" : modify_loc_end, + "old_string" : old_str_of_interest, + "new_string" : solc_version + }) diff --git a/utils/slither_format/format_unused_state.py b/utils/slither_format/format_unused_state.py new file mode 100644 index 000000000..20b0e08b8 --- /dev/null +++ b/utils/slither_format/format_unused_state.py @@ -0,0 +1,19 @@ +class FormatUnusedState: + + @staticmethod + def format(slither, patches, elements): + for element in elements: + FormatUnusedState.create_patch(slither, patches, element['source_mapping']['filename'], element['source_mapping']['start']) + + @staticmethod + def create_patch(slither, patches, in_file, modify_loc_start): + in_file_str = slither.source_code[in_file] + old_str_of_interest = in_file_str[modify_loc_start:] + patches[in_file].append({ + "detector" : "unused-state", + "start" : modify_loc_start, + "end" : modify_loc_start + len(old_str_of_interest.partition(';')[0]) + 1, + "old_string" : old_str_of_interest.partition(';')[0] + old_str_of_interest.partition(';')[1], + "new_string" : "" + }) + diff --git a/utils/slither_format/slither_format.py b/utils/slither_format/slither_format.py new file mode 100644 index 000000000..1c1831b59 --- /dev/null +++ b/utils/slither_format/slither_format.py @@ -0,0 +1,132 @@ +import sys, re +from collections import defaultdict +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 slither.slithir.operations import InternalCall +from slither.core.expressions.call_expression import CallExpression +from slither.core.expressions.expression import Expression +from slither.core.expressions.identifier import Identifier +from slither_format.format_unused_state import FormatUnusedState +from slither_format.format_solc_version import FormatSolcVersion +from slither_format.format_pragma import FormatPragma +from slither_format.format_naming_convention import FormatNamingConvention +from slither_format.format_external_function import FormatExternalFunction +from slither_format.format_constable_states import FormatConstableStates +from slither_format.format_constant_function import FormatConstantFunction + +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_patches(patches) + if args.verbose: + print("Number of Slither results: " + str(number_of_slither_results)) + print_patches(patches) + apply_patches(slither, patches) + +def sort_patches(patches): + for file in patches: + n = len(patches[file]) + for i in range(n): + for j in range (0,n-i-1): + if int(patches[file][j]['start']) >= int(patches[file][j+1]['end']): + temp = patches[file][j+1] + patches[file][j+1] = patches[file][j] + patches[file][j] = temp + +def apply_patches(slither, patches): + for file in patches: + _in_file = file + in_file_str = slither.source_code[_in_file] + out_file_str = "" + for i in range(len(patches[file])): + if i != 0: + out_file_str += in_file_str[int(patches[file][i-1]['end']):int(patches[file][i]['start'])] + else: + out_file_str += in_file_str[:int(patches[file][i]['start'])] + out_file_str += patches[file][i]['new_string'] + out_file_str += in_file_str[int(patches[file][i]['end']):] + out_file = open(_in_file+".format",'w') + out_file.write(out_file_str) + out_file.close() + +def print_patches(patches): + number_of_patches = 0 + for file in patches: + number_of_patches += len(patches[file]) + print("Number of patches: " + str(number_of_patches)) + for file in patches: + print("Patch file: " + file) + for patch in patches[file]: + 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'])) + +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: + print("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 + number_of_slither_results += 1 + return number_of_slither_results + diff --git a/utils/slither_format/tests/.gitignore b/utils/slither_format/tests/.gitignore new file mode 100644 index 000000000..9f1f4d954 --- /dev/null +++ b/utils/slither_format/tests/.gitignore @@ -0,0 +1 @@ +*.patch.* \ No newline at end of file diff --git a/utils/slither_format/tests/real_world/0x0000000000b3F879cb30FE243b4Dfee438691c04_GasToken2.sol b/utils/slither_format/tests/real_world/0x0000000000b3F879cb30FE243b4Dfee438691c04_GasToken2.sol new file mode 100644 index 000000000..d122420cf --- /dev/null +++ b/utils/slither_format/tests/real_world/0x0000000000b3F879cb30FE243b4Dfee438691c04_GasToken2.sol @@ -0,0 +1,332 @@ +pragma solidity ^0.4.10; + +contract GasToken2 { + ////////////////////////////////////////////////////////////////////////// + // RLP.sol + // Due to some unexplained bug, we get a slightly different bytecode if + // we use an import, and are then unable to verify the code in Etherscan + ////////////////////////////////////////////////////////////////////////// + + uint256 constant ADDRESS_BYTES = 20; + uint256 constant MAX_SINGLE_BYTE = 128; + uint256 constant MAX_NONCE = 256**9 - 1; + + // count number of bytes required to represent an unsigned integer + function count_bytes(uint256 n) constant internal returns (uint256 c) { + uint i = 0; + uint mask = 1; + while (n >= mask) { + i += 1; + mask *= 256; + } + + return i; + } + + function mk_contract_address(address a, uint256 n) constant internal returns (address rlp) { + /* + * make sure the RLP encoding fits in one word: + * total_length 1 byte + * address_length 1 byte + * address 20 bytes + * nonce_length 1 byte (or 0) + * nonce 1-9 bytes + * ========== + * 24-32 bytes + */ + require(n <= MAX_NONCE); + + // number of bytes required to write down the nonce + uint256 nonce_bytes; + // length in bytes of the RLP encoding of the nonce + uint256 nonce_rlp_len; + + if (0 < n && n < MAX_SINGLE_BYTE) { + // nonce fits in a single byte + // RLP(nonce) = nonce + nonce_bytes = 1; + nonce_rlp_len = 1; + } else { + // RLP(nonce) = [num_bytes_in_nonce nonce] + nonce_bytes = count_bytes(n); + nonce_rlp_len = nonce_bytes + 1; + } + + // [address_length(1) address(20) nonce_length(0 or 1) nonce(1-9)] + uint256 tot_bytes = 1 + ADDRESS_BYTES + nonce_rlp_len; + + // concatenate all parts of the RLP encoding in the leading bytes of + // one 32-byte word + uint256 word = ((192 + tot_bytes) * 256**31) + + ((128 + ADDRESS_BYTES) * 256**30) + + (uint256(a) * 256**10); + + if (0 < n && n < MAX_SINGLE_BYTE) { + word += n * 256**9; + } else { + word += (128 + nonce_bytes) * 256**9; + word += n * 256**(9 - nonce_bytes); + } + + uint256 hash; + + assembly { + let mem_start := mload(0x40) // get a pointer to free memory + mstore(0x40, add(mem_start, 0x20)) // update the pointer + + mstore(mem_start, word) // store the rlp encoding + hash := sha3(mem_start, + add(tot_bytes, 1)) // hash the rlp encoding + } + + // interpret hash as address (20 least significant bytes) + return address(hash); + } + + ////////////////////////////////////////////////////////////////////////// + // Generic ERC20 + ////////////////////////////////////////////////////////////////////////// + + // owner -> amount + mapping(address => uint256) s_balances; + // owner -> spender -> max amount + mapping(address => mapping(address => uint256)) s_allowances; + + event Transfer(address indexed from, address indexed to, uint256 value); + + event Approval(address indexed owner, address indexed spender, uint256 value); + + // Spec: Get the account balance of another account with address `owner` + function balanceOf(address owner) public constant returns (uint256 balance) { + return s_balances[owner]; + } + + function internalTransfer(address from, address to, uint256 value) internal returns (bool success) { + if (value <= s_balances[from]) { + s_balances[from] -= value; + s_balances[to] += value; + Transfer(from, to, value); + return true; + } else { + return false; + } + } + + // Spec: Send `value` amount of tokens to address `to` + function transfer(address to, uint256 value) public returns (bool success) { + address from = msg.sender; + return internalTransfer(from, to, value); + } + + // Spec: Send `value` amount of tokens from address `from` to address `to` + function transferFrom(address from, address to, uint256 value) public returns (bool success) { + address spender = msg.sender; + if(value <= s_allowances[from][spender] && internalTransfer(from, to, value)) { + s_allowances[from][spender] -= value; + return true; + } else { + return false; + } + } + + // Spec: Allow `spender` to withdraw from your account, multiple times, up + // to the `value` amount. If this function is called again it overwrites the + // current allowance with `value`. + function approve(address spender, uint256 value) public returns (bool success) { + address owner = msg.sender; + if (value != 0 && s_allowances[owner][spender] != 0) { + return false; + } + s_allowances[owner][spender] = value; + Approval(owner, spender, value); + return true; + } + + // Spec: Returns the `amount` which `spender` is still allowed to withdraw + // from `owner`. + // What if the allowance is higher than the balance of the `owner`? + // Callers should be careful to use min(allowance, balanceOf) to make sure + // that the allowance is actually present in the account! + function allowance(address owner, address spender) public constant returns (uint256 remaining) { + return s_allowances[owner][spender]; + } + + ////////////////////////////////////////////////////////////////////////// + // GasToken specifics + ////////////////////////////////////////////////////////////////////////// + + uint8 constant public decimals = 2; + string constant public name = "Gastoken.io"; + string constant public symbol = "GST2"; + + // We build a queue of nonces at which child contracts are stored. s_head is + // the nonce at the head of the queue, s_tail is the nonce behind the tail + // of the queue. The queue grows at the head and shrinks from the tail. + // Note that when and only when a contract CREATEs another contract, the + // creating contract's nonce is incremented. + // The first child contract is created with nonce == 1, the second child + // contract is created with nonce == 2, and so on... + // For example, if there are child contracts at nonces [2,3,4], + // then s_head == 4 and s_tail == 1. If there are no child contracts, + // s_head == s_tail. + uint256 s_head; + uint256 s_tail; + + // totalSupply gives the number of tokens currently in existence + // Each token corresponds to one child contract that can be SELFDESTRUCTed + // for a gas refund. + function totalSupply() public constant returns (uint256 supply) { + return s_head - s_tail; + } + + // Creates a child contract that can only be destroyed by this contract. + function makeChild() internal returns (address addr) { + assembly { + // EVM assembler of runtime portion of child contract: + // ;; Pseudocode: if (msg.sender != 0x0000000000b3f879cb30fe243b4dfee438691c04) { throw; } + // ;; suicide(msg.sender) + // PUSH15 0xb3f879cb30fe243b4dfee438691c04 ;; hardcoded address of this contract + // CALLER + // XOR + // PC + // JUMPI + // CALLER + // SELFDESTRUCT + // Or in binary: 6eb3f879cb30fe243b4dfee438691c043318585733ff + // Since the binary is so short (22 bytes), we can get away + // with a very simple initcode: + // PUSH22 0x6eb3f879cb30fe243b4dfee438691c043318585733ff + // PUSH1 0 + // MSTORE ;; at this point, memory locations mem[10] through + // ;; mem[31] contain the runtime portion of the child + // ;; contract. all that's left to do is to RETURN this + // ;; chunk of memory. + // PUSH1 22 ;; length + // PUSH1 10 ;; offset + // RETURN + // Or in binary: 756eb3f879cb30fe243b4dfee438691c043318585733ff6000526016600af3 + // Almost done! All we have to do is put this short (31 bytes) blob into + // memory and call CREATE with the appropriate offsets. + let solidity_free_mem_ptr := mload(0x40) + mstore(solidity_free_mem_ptr, 0x00756eb3f879cb30fe243b4dfee438691c043318585733ff6000526016600af3) + addr := create(0, add(solidity_free_mem_ptr, 1), 31) + } + } + + // Mints `value` new sub-tokens (e.g. cents, pennies, ...) by creating `value` + // new child contracts. The minted tokens are owned by the caller of this + // function. + function mint(uint256 value) public { + for (uint256 i = 0; i < value; i++) { + makeChild(); + } + s_head += value; + s_balances[msg.sender] += value; + } + + // Destroys `value` child contracts and updates s_tail. + // + // This function is affected by an issue in solc: https://github.com/ethereum/solidity/issues/2999 + // The `mk_contract_address(this, i).call();` doesn't forward all available gas, but only GAS - 25710. + // As a result, when this line is executed with e.g. 30000 gas, the callee will have less than 5000 gas + // available and its SELFDESTRUCT operation will fail leading to no gas refund occurring. + // The remaining ~29000 gas left after the call is enough to update s_tail and the caller's balance. + // Hence tokens will have been destroyed without a commensurate gas refund. + // Fortunately, there is a simple workaround: + // Whenever you call free, freeUpTo, freeFrom, or freeUpToFrom, ensure that you pass at least + // 25710 + `value` * (1148 + 5722 + 150) gas. (It won't all be used) + function destroyChildren(uint256 value) internal { + uint256 tail = s_tail; + // tail points to slot behind the last contract in the queue + for (uint256 i = tail + 1; i <= tail + value; i++) { + mk_contract_address(this, i).call(); + } + + s_tail = tail + value; + } + + // Frees `value` sub-tokens (e.g. cents, pennies, ...) belonging to the + // caller of this function by destroying `value` child contracts, which + // will trigger a partial gas refund. + // You should ensure that you pass at least 25710 + `value` * (1148 + 5722 + 150) gas + // when calling this function. For details, see the comment above `destroyChilden`. + function free(uint256 value) public returns (bool success) { + uint256 from_balance = s_balances[msg.sender]; + if (value > from_balance) { + return false; + } + + destroyChildren(value); + + s_balances[msg.sender] = from_balance - value; + + return true; + } + + // Frees up to `value` sub-tokens. Returns how many tokens were freed. + // Otherwise, identical to free. + // You should ensure that you pass at least 25710 + `value` * (1148 + 5722 + 150) gas + // when calling this function. For details, see the comment above `destroyChilden`. + function freeUpTo(uint256 value) public returns (uint256 freed) { + uint256 from_balance = s_balances[msg.sender]; + if (value > from_balance) { + value = from_balance; + } + + destroyChildren(value); + + s_balances[msg.sender] = from_balance - value; + + return value; + } + + // Frees `value` sub-tokens owned by address `from`. Requires that `msg.sender` + // has been approved by `from`. + // You should ensure that you pass at least 25710 + `value` * (1148 + 5722 + 150) gas + // when calling this function. For details, see the comment above `destroyChilden`. + function freeFrom(address from, uint256 value) public returns (bool success) { + address spender = msg.sender; + uint256 from_balance = s_balances[from]; + if (value > from_balance) { + return false; + } + + mapping(address => uint256) from_allowances = s_allowances[from]; + uint256 spender_allowance = from_allowances[spender]; + if (value > spender_allowance) { + return false; + } + + destroyChildren(value); + + s_balances[from] = from_balance - value; + from_allowances[spender] = spender_allowance - value; + + return true; + } + + // Frees up to `value` sub-tokens owned by address `from`. Returns how many tokens were freed. + // Otherwise, identical to `freeFrom`. + // You should ensure that you pass at least 25710 + `value` * (1148 + 5722 + 150) gas + // when calling this function. For details, see the comment above `destroyChilden`. + function freeFromUpTo(address from, uint256 value) public returns (uint256 freed) { + address spender = msg.sender; + uint256 from_balance = s_balances[from]; + if (value > from_balance) { + value = from_balance; + } + + mapping(address => uint256) from_allowances = s_allowances[from]; + uint256 spender_allowance = from_allowances[spender]; + if (value > spender_allowance) { + value = spender_allowance; + } + + destroyChildren(value); + + s_balances[from] = from_balance - value; + from_allowances[spender] = spender_allowance - value; + + return value; + } +} \ No newline at end of file diff --git a/utils/slither_format/tests/real_world/0x006bea43baa3f7a6f765f14f10a1a1b08334ef45_StoxSmartToken.sol b/utils/slither_format/tests/real_world/0x006bea43baa3f7a6f765f14f10a1a1b08334ef45_StoxSmartToken.sol new file mode 100644 index 000000000..db6b2796b --- /dev/null +++ b/utils/slither_format/tests/real_world/0x006bea43baa3f7a6f765f14f10a1a1b08334ef45_StoxSmartToken.sol @@ -0,0 +1,880 @@ +pragma solidity ^0.4.11; + +/* + Owned contract interface +*/ +contract IOwned { + // this function isn't abstract since the compiler emits automatically generated getter functions as external + function owner() public constant returns (address owner) { owner; } + + function transferOwnership(address _newOwner) public; + function acceptOwnership() public; +} + +/* + ERC20 Standard Token interface +*/ +contract IERC20Token { + // these functions aren't abstract since the compiler emits automatically generated getter functions as external + function name() public constant returns (string name) { name; } + function symbol() public constant returns (string symbol) { symbol; } + function decimals() public constant returns (uint8 decimals) { decimals; } + function totalSupply() public constant returns (uint256 totalSupply) { totalSupply; } + function balanceOf(address _owner) public constant returns (uint256 balance) { _owner; balance; } + function allowance(address _owner, address _spender) public constant returns (uint256 remaining) { _owner; _spender; remaining; } + + function transfer(address _to, uint256 _value) public returns (bool success); + function transferFrom(address _from, address _to, uint256 _value) public returns (bool success); + function approve(address _spender, uint256 _value) public returns (bool success); +} + +/* + Token Holder interface +*/ +contract ITokenHolder is IOwned { + function withdrawTokens(IERC20Token _token, address _to, uint256 _amount) public; +} + +/* + Smart Token interface +*/ +contract ISmartToken is ITokenHolder, IERC20Token { + function disableTransfers(bool _disable) public; + function issue(address _to, uint256 _amount) public; + function destroy(address _from, uint256 _amount) public; +} + +/* + Overflow protected math functions +*/ +contract SafeMath { + /** + constructor + */ + function SafeMath() { + } + + /** + @dev returns the sum of _x and _y, asserts if the calculation overflows + + @param _x value 1 + @param _y value 2 + + @return sum + */ + function safeAdd(uint256 _x, uint256 _y) internal returns (uint256) { + uint256 z = _x + _y; + assert(z >= _x); + return z; + } + + /** + @dev returns the difference of _x minus _y, asserts if the subtraction results in a negative number + + @param _x minuend + @param _y subtrahend + + @return difference + */ + function safeSub(uint256 _x, uint256 _y) internal returns (uint256) { + assert(_x >= _y); + return _x - _y; + } + + /** + @dev returns the product of multiplying _x by _y, asserts if the calculation overflows + + @param _x factor 1 + @param _y factor 2 + + @return product + */ + function safeMul(uint256 _x, uint256 _y) internal returns (uint256) { + uint256 z = _x * _y; + assert(_x == 0 || z / _x == _y); + return z; + } +} + +/** + ERC20 Standard Token implementation +*/ +contract ERC20Token is IERC20Token, SafeMath { + string public standard = 'Token 0.1'; + string public name = ''; + string public symbol = ''; + uint8 public decimals = 0; + uint256 public totalSupply = 0; + mapping (address => uint256) public balanceOf; + mapping (address => mapping (address => uint256)) public allowance; + + event Transfer(address indexed _from, address indexed _to, uint256 _value); + event Approval(address indexed _owner, address indexed _spender, uint256 _value); + + /** + @dev constructor + + @param _name token name + @param _symbol token symbol + @param _decimals decimal points, for display purposes + */ + function ERC20Token(string _name, string _symbol, uint8 _decimals) { + require(bytes(_name).length > 0 && bytes(_symbol).length > 0); // validate input + + name = _name; + symbol = _symbol; + decimals = _decimals; + } + + // validates an address - currently only checks that it isn't null + modifier validAddress(address _address) { + require(_address != 0x0); + _; + } + + /** + @dev send coins + throws on any error rather then return a false flag to minimize user errors + + @param _to target address + @param _value transfer amount + + @return true if the transfer was successful, false if it wasn't + */ + function transfer(address _to, uint256 _value) + public + validAddress(_to) + returns (bool success) + { + balanceOf[msg.sender] = safeSub(balanceOf[msg.sender], _value); + balanceOf[_to] = safeAdd(balanceOf[_to], _value); + Transfer(msg.sender, _to, _value); + return true; + } + + /** + @dev an account/contract attempts to get the coins + throws on any error rather then return a false flag to minimize user errors + + @param _from source address + @param _to target address + @param _value transfer amount + + @return true if the transfer was successful, false if it wasn't + */ + function transferFrom(address _from, address _to, uint256 _value) + public + validAddress(_from) + validAddress(_to) + returns (bool success) + { + allowance[_from][msg.sender] = safeSub(allowance[_from][msg.sender], _value); + balanceOf[_from] = safeSub(balanceOf[_from], _value); + balanceOf[_to] = safeAdd(balanceOf[_to], _value); + Transfer(_from, _to, _value); + return true; + } + + /** + @dev allow another account/contract to spend some tokens on your behalf + throws on any error rather then return a false flag to minimize user errors + + also, to minimize the risk of the approve/transferFrom attack vector + (see https://docs.google.com/document/d/1YLPtQxZu1UAvO9cZ1O2RPXBbT0mooh4DYKjA_jp-RLM/), approve has to be called twice + in 2 separate transactions - once to change the allowance to 0 and secondly to change it to the new allowance value + + @param _spender approved address + @param _value allowance amount + + @return true if the approval was successful, false if it wasn't + */ + function approve(address _spender, uint256 _value) + public + validAddress(_spender) + returns (bool success) + { + // if the allowance isn't 0, it can only be updated to 0 to prevent an allowance change immediately after withdrawal + require(_value == 0 || allowance[msg.sender][_spender] == 0); + + allowance[msg.sender][_spender] = _value; + Approval(msg.sender, _spender, _value); + return true; + } +} + +/* + Provides support and utilities for contract ownership +*/ +contract Owned is IOwned { + address public owner; + address public newOwner; + + event OwnerUpdate(address _prevOwner, address _newOwner); + + /** + @dev constructor + */ + function Owned() { + owner = msg.sender; + } + + // allows execution by the owner only + modifier ownerOnly { + assert(msg.sender == owner); + _; + } + + /** + @dev allows transferring the contract ownership + the new owner still need to accept the transfer + can only be called by the contract owner + + @param _newOwner new contract owner + */ + function transferOwnership(address _newOwner) public ownerOnly { + require(_newOwner != owner); + newOwner = _newOwner; + } + + /** + @dev used by a new owner to accept an ownership transfer + */ + function acceptOwnership() public { + require(msg.sender == newOwner); + OwnerUpdate(owner, newOwner); + owner = newOwner; + newOwner = 0x0; + } +} + +/* + We consider every contract to be a 'token holder' since it's currently not possible + for a contract to deny receiving tokens. + + The TokenHolder's contract sole purpose is to provide a safety mechanism that allows + the owner to send tokens that were sent to the contract by mistake back to their sender. +*/ +contract TokenHolder is ITokenHolder, Owned { + /** + @dev constructor + */ + function TokenHolder() { + } + + // validates an address - currently only checks that it isn't null + modifier validAddress(address _address) { + require(_address != 0x0); + _; + } + + // verifies that the address is different than this contract address + modifier notThis(address _address) { + require(_address != address(this)); + _; + } + + /** + @dev withdraws tokens held by the contract and sends them to an account + can only be called by the owner + + @param _token ERC20 token contract address + @param _to account to receive the new amount + @param _amount amount to withdraw + */ + function withdrawTokens(IERC20Token _token, address _to, uint256 _amount) + public + ownerOnly + validAddress(_token) + validAddress(_to) + notThis(_to) + { + assert(_token.transfer(_to, _amount)); + } +} + +/* + Smart Token v0.2 + + 'Owned' is specified here for readability reasons +*/ +contract SmartToken is ISmartToken, ERC20Token, Owned, TokenHolder { + string public version = '0.2'; + + bool public transfersEnabled = true; // true if transfer/transferFrom are enabled, false if not + + // triggered when a smart token is deployed - the _token address is defined for forward compatibility, in case we want to trigger the event from a factory + event NewSmartToken(address _token); + // triggered when the total supply is increased + event Issuance(uint256 _amount); + // triggered when the total supply is decreased + event Destruction(uint256 _amount); + + /** + @dev constructor + + @param _name token name + @param _symbol token short symbol, 1-6 characters + @param _decimals for display purposes only + */ + function SmartToken(string _name, string _symbol, uint8 _decimals) + ERC20Token(_name, _symbol, _decimals) + { + require(bytes(_symbol).length <= 6); // validate input + NewSmartToken(address(this)); + } + + // allows execution only when transfers aren't disabled + modifier transfersAllowed { + assert(transfersEnabled); + _; + } + + /** + @dev disables/enables transfers + can only be called by the contract owner + + @param _disable true to disable transfers, false to enable them + */ + function disableTransfers(bool _disable) public ownerOnly { + transfersEnabled = !_disable; + } + + /** + @dev increases the token supply and sends the new tokens to an account + can only be called by the contract owner + + @param _to account to receive the new amount + @param _amount amount to increase the supply by + */ + function issue(address _to, uint256 _amount) + public + ownerOnly + validAddress(_to) + notThis(_to) + { + totalSupply = safeAdd(totalSupply, _amount); + balanceOf[_to] = safeAdd(balanceOf[_to], _amount); + + Issuance(_amount); + Transfer(this, _to, _amount); + } + + /** + @dev removes tokens from an account and decreases the token supply + can only be called by the contract owner + + @param _from account to remove the amount from + @param _amount amount to decrease the supply by + */ + function destroy(address _from, uint256 _amount) + public + ownerOnly + { + balanceOf[_from] = safeSub(balanceOf[_from], _amount); + totalSupply = safeSub(totalSupply, _amount); + + Transfer(_from, this, _amount); + Destruction(_amount); + } + + // ERC20 standard method overrides with some extra functionality + + /** + @dev send coins + throws on any error rather then return a false flag to minimize user errors + note that when transferring to the smart token's address, the coins are actually destroyed + + @param _to target address + @param _value transfer amount + + @return true if the transfer was successful, false if it wasn't + */ + function transfer(address _to, uint256 _value) public transfersAllowed returns (bool success) { + assert(super.transfer(_to, _value)); + + // transferring to the contract address destroys tokens + if (_to == address(this)) { + balanceOf[_to] -= _value; + totalSupply -= _value; + Destruction(_value); + } + + return true; + } + + /** + @dev an account/contract attempts to get the coins + throws on any error rather then return a false flag to minimize user errors + note that when transferring to the smart token's address, the coins are actually destroyed + + @param _from source address + @param _to target address + @param _value transfer amount + + @return true if the transfer was successful, false if it wasn't + */ + function transferFrom(address _from, address _to, uint256 _value) public transfersAllowed returns (bool success) { + assert(super.transferFrom(_from, _to, _value)); + + // transferring to the contract address destroys tokens + if (_to == address(this)) { + balanceOf[_to] -= _value; + totalSupply -= _value; + Destruction(_value); + } + + return true; + } +} + +/// @title Ownable +/// @dev The Ownable contract has an owner address, and provides basic authorization control functions, this simplifies +/// & the implementation of "user permissions". +contract Ownable { + address public owner; + address public newOwnerCandidate; + + event OwnershipRequested(address indexed _by, address indexed _to); + event OwnershipTransferred(address indexed _from, address indexed _to); + + /// @dev The Ownable constructor sets the original `owner` of the contract to the sender account. + function Ownable() { + owner = msg.sender; + } + + /// @dev Throws if called by any account other than the owner. + modifier onlyOwner() { + if (msg.sender != owner) { + throw; + } + + _; + } + + /// @dev Proposes to transfer control of the contract to a newOwnerCandidate. + /// @param _newOwnerCandidate address The address to transfer ownership to. + function transferOwnership(address _newOwnerCandidate) onlyOwner { + require(_newOwnerCandidate != address(0)); + + newOwnerCandidate = _newOwnerCandidate; + + OwnershipRequested(msg.sender, newOwnerCandidate); + } + + /// @dev Accept ownership transfer. This method needs to be called by the perviously proposed owner. + function acceptOwnership() { + if (msg.sender == newOwnerCandidate) { + owner = newOwnerCandidate; + newOwnerCandidate = address(0); + + OwnershipTransferred(owner, newOwnerCandidate); + } + } +} + +/// @title Math operations with safety checks +library SaferMath { + function mul(uint256 a, uint256 b) internal returns (uint256) { + uint256 c = a * b; + assert(a == 0 || c / a == b); + return c; + } + + function div(uint256 a, uint256 b) internal returns (uint256) { + // assert(b > 0); // Solidity automatically throws when dividing by 0 + uint256 c = a / b; + // assert(a == b * c + a % b); // There is no case in which this doesn't hold + return c; + } + + function sub(uint256 a, uint256 b) internal returns (uint256) { + assert(b <= a); + return a - b; + } + + function add(uint256 a, uint256 b) internal returns (uint256) { + uint256 c = a + b; + assert(c >= a); + return c; + } + + function max64(uint64 a, uint64 b) internal constant returns (uint64) { + return a >= b ? a : b; + } + + function min64(uint64 a, uint64 b) internal constant returns (uint64) { + return a < b ? a : b; + } + + function max256(uint256 a, uint256 b) internal constant returns (uint256) { + return a >= b ? a : b; + } + + function min256(uint256 a, uint256 b) internal constant returns (uint256) { + return a < b ? a : b; + } +} + + +/// @title Stox Smart Token +contract StoxSmartToken is SmartToken { + function StoxSmartToken() SmartToken('Stox', 'STX', 18) { + disableTransfers(true); + } +} + + +/// @title Vesting trustee +contract Trustee is Ownable { + using SaferMath for uint256; + + // The address of the STX ERC20 token. + StoxSmartToken public stox; + + struct Grant { + uint256 value; + uint256 start; + uint256 cliff; + uint256 end; + uint256 transferred; + bool revokable; + } + + // Grants holder. + mapping (address => Grant) public grants; + + // Total tokens available for vesting. + uint256 public totalVesting; + + event NewGrant(address indexed _from, address indexed _to, uint256 _value); + event UnlockGrant(address indexed _holder, uint256 _value); + event RevokeGrant(address indexed _holder, uint256 _refund); + + /// @dev Constructor that initializes the address of the StoxSmartToken contract. + /// @param _stox StoxSmartToken The address of the previously deployed StoxSmartToken smart contract. + function Trustee(StoxSmartToken _stox) { + require(_stox != address(0)); + + stox = _stox; + } + + /// @dev Grant tokens to a specified address. + /// @param _to address The address to grant tokens to. + /// @param _value uint256 The amount of tokens to be granted. + /// @param _start uint256 The beginning of the vesting period. + /// @param _cliff uint256 Duration of the cliff period. + /// @param _end uint256 The end of the vesting period. + /// @param _revokable bool Whether the grant is revokable or not. + function grant(address _to, uint256 _value, uint256 _start, uint256 _cliff, uint256 _end, bool _revokable) + public onlyOwner { + require(_to != address(0)); + require(_value > 0); + + // Make sure that a single address can be granted tokens only once. + require(grants[_to].value == 0); + + // Check for date inconsistencies that may cause unexpected behavior. + require(_start <= _cliff && _cliff <= _end); + + // Check that this grant doesn't exceed the total amount of tokens currently available for vesting. + require(totalVesting.add(_value) <= stox.balanceOf(address(this))); + + // Assign a new grant. + grants[_to] = Grant({ + value: _value, + start: _start, + cliff: _cliff, + end: _end, + transferred: 0, + revokable: _revokable + }); + + // Tokens granted, reduce the total amount available for vesting. + totalVesting = totalVesting.add(_value); + + NewGrant(msg.sender, _to, _value); + } + + /// @dev Revoke the grant of tokens of a specifed address. + /// @param _holder The address which will have its tokens revoked. + function revoke(address _holder) public onlyOwner { + Grant grant = grants[_holder]; + + require(grant.revokable); + + // Send the remaining STX back to the owner. + uint256 refund = grant.value.sub(grant.transferred); + + // Remove the grant. + delete grants[_holder]; + + totalVesting = totalVesting.sub(refund); + stox.transfer(msg.sender, refund); + + RevokeGrant(_holder, refund); + } + + /// @dev Calculate the total amount of vested tokens of a holder at a given time. + /// @param _holder address The address of the holder. + /// @param _time uint256 The specific time. + /// @return a uint256 representing a holder's total amount of vested tokens. + function vestedTokens(address _holder, uint256 _time) public constant returns (uint256) { + Grant grant = grants[_holder]; + if (grant.value == 0) { + return 0; + } + + return calculateVestedTokens(grant, _time); + } + + /// @dev Calculate amount of vested tokens at a specifc time. + /// @param _grant Grant The vesting grant. + /// @param _time uint256 The time to be checked + /// @return An uint256 representing the amount of vested tokens of a specific grant. + /// | _/-------- vestedTokens rect + /// | _/ + /// | _/ + /// | _/ + /// | _/ + /// | / + /// | .| + /// | . | + /// | . | + /// | . | + /// | . | + /// | . | + /// +===+===========+---------+----------> time + /// Start Cliff End + function calculateVestedTokens(Grant _grant, uint256 _time) private constant returns (uint256) { + // If we're before the cliff, then nothing is vested. + if (_time < _grant.cliff) { + return 0; + } + + // If we're after the end of the vesting period - everything is vested; + if (_time >= _grant.end) { + return _grant.value; + } + + // Interpolate all vested tokens: vestedTokens = tokens/// (time - start) / (end - start) + return _grant.value.mul(_time.sub(_grant.start)).div(_grant.end.sub(_grant.start)); + } + + /// @dev Unlock vested tokens and transfer them to their holder. + /// @return a uint256 representing the amount of vested tokens transferred to their holder. + function unlockVestedTokens() public { + Grant grant = grants[msg.sender]; + require(grant.value != 0); + + // Get the total amount of vested tokens, acccording to grant. + uint256 vested = calculateVestedTokens(grant, now); + if (vested == 0) { + return; + } + + // Make sure the holder doesn't transfer more than what he already has. + uint256 transferable = vested.sub(grant.transferred); + if (transferable == 0) { + return; + } + + grant.transferred = grant.transferred.add(transferable); + totalVesting = totalVesting.sub(transferable); + stox.transfer(msg.sender, transferable); + + UnlockGrant(msg.sender, transferable); + } +} + + +/// @title Stox Smart Token sale +contract StoxSmartTokenSale is Ownable { + using SaferMath for uint256; + + uint256 public constant DURATION = 14 days; + + bool public isFinalized = false; + bool public isDistributed = false; + + // The address of the STX ERC20 token. + StoxSmartToken public stox; + + // The address of the token allocation trustee; + Trustee public trustee; + + uint256 public startTime = 0; + uint256 public endTime = 0; + address public fundingRecipient; + + uint256 public tokensSold = 0; + + // TODO: update to the correct values. + uint256 public constant ETH_CAP = 148000; + uint256 public constant EXCHANGE_RATE = 200; // 200 STX for ETH + uint256 public constant TOKEN_SALE_CAP = ETH_CAP * EXCHANGE_RATE * 10 ** 18; + + event TokensIssued(address indexed _to, uint256 _tokens); + + /// @dev Throws if called when not during sale. + modifier onlyDuringSale() { + if (tokensSold >= TOKEN_SALE_CAP || now < startTime || now >= endTime) { + throw; + } + + _; + } + + /// @dev Throws if called before sale ends. + modifier onlyAfterSale() { + if (!(tokensSold >= TOKEN_SALE_CAP || now >= endTime)) { + throw; + } + + _; + } + + /// @dev Constructor that initializes the sale conditions. + /// @param _fundingRecipient address The address of the funding recipient. + /// @param _startTime uint256 The start time of the token sale. + function StoxSmartTokenSale(address _stox, address _fundingRecipient, uint256 _startTime) { + require(_stox != address(0)); + require(_fundingRecipient != address(0)); + require(_startTime > now); + + stox = StoxSmartToken(_stox); + + fundingRecipient = _fundingRecipient; + startTime = _startTime; + endTime = startTime + DURATION; + } + + /// @dev Distributed tokens to the partners who have participated during the pre-sale. + function distributePartnerTokens() external onlyOwner { + require(!isDistributed); + + assert(tokensSold == 0); + assert(stox.totalSupply() == 0); + + // Distribute strategic tokens to partners. Please note, that this address doesn't represent a single entity or + // person and will be only used to distribute tokens to 30~ partners. + // + // Please expect to see token transfers from this address in the first 24 hours after the token sale ends. + issueTokens(0x9065260ef6830f6372F1Bde408DeC57Fe3150530, 14800000 * 10 ** 18); + + isDistributed = true; + } + + /// @dev Finalizes the token sale event. + function finalize() external onlyAfterSale { + if (isFinalized) { + throw; + } + + // Grant vesting grants. + // + // TODO: use real addresses. + trustee = new Trustee(stox); + + // Since only 50% of the tokens will be sold, we will automatically issue the same amount of sold STX to the + // trustee. + uint256 unsoldTokens = tokensSold; + + // Issue 55% of the remaining tokens (== 27.5%) go to strategic parternships. + uint256 strategicPartnershipTokens = unsoldTokens.mul(55).div(100); + + // Note: we will substract the bonus tokens from this grant, since they were already issued for the pre-sale + // strategic partners and should've been taken from this allocation. + stox.issue(0xbC14105ccDdeAadB96Ba8dCE18b40C45b6bACf58, strategicPartnershipTokens); + + // Issue the remaining tokens as vesting grants: + stox.issue(trustee, unsoldTokens.sub(strategicPartnershipTokens)); + + // 25% of the remaining tokens (== 12.5%) go to Invest.com, at uniform 12 months vesting schedule. + trustee.grant(0xb54c6a870d4aD65e23d471Fb7941aD271D323f5E, unsoldTokens.mul(25).div(100), now, now, + now.add(1 years), true); + + // 20% of the remaining tokens (== 10%) go to Stox team, at uniform 24 months vesting schedule. + trustee.grant(0x4eB4Cd1D125d9d281709Ff38d65b99a6927b46c1, unsoldTokens.mul(20).div(100), now, now, + now.add(2 years), true); + + // Re-enable transfers after the token sale. + stox.disableTransfers(false); + + isFinalized = true; + } + + /// @dev Create and sell tokens to the caller. + /// @param _recipient address The address of the recipient. + function create(address _recipient) public payable onlyDuringSale { + require(_recipient != address(0)); + require(msg.value > 0); + + assert(isDistributed); + + uint256 tokens = SaferMath.min256(msg.value.mul(EXCHANGE_RATE), TOKEN_SALE_CAP.sub(tokensSold)); + uint256 contribution = tokens.div(EXCHANGE_RATE); + + issueTokens(_recipient, tokens); + + // Transfer the funds to the funding recipient. + fundingRecipient.transfer(contribution); + + // Refund the msg.sender, in the case that not all of its ETH was used. This can happen only when selling the + // last chunk of STX. + uint256 refund = msg.value.sub(contribution); + if (refund > 0) { + msg.sender.transfer(refund); + } + } + + /// @dev Issues tokens for the recipient. + /// @param _recipient address The address of the recipient. + /// @param _tokens uint256 The amount of tokens to issue. + function issueTokens(address _recipient, uint256 _tokens) private { + // Update total sold tokens. + tokensSold = tokensSold.add(_tokens); + + stox.issue(_recipient, _tokens); + + TokensIssued(_recipient, _tokens); + } + + /// @dev Fallback function that will delegate the request to create. + function () external payable onlyDuringSale { + create(msg.sender); + } + + /// @dev Proposes to transfer control of the StoxSmartToken contract to a new owner. + /// @param _newOwnerCandidate address The address to transfer ownership to. + /// + /// Note that: + /// 1. The new owner will need to call StoxSmartToken's acceptOwnership directly in order to accept the ownership. + /// 2. Calling this method during the token sale will prevent the token sale to continue, since only the owner of + /// the StoxSmartToken contract can issue new tokens. + function transferSmartTokenOwnership(address _newOwnerCandidate) external onlyOwner { + stox.transferOwnership(_newOwnerCandidate); + } + + /// @dev Accepts new ownership on behalf of the StoxSmartToken contract. This can be used, by the token sale + /// contract itself to claim back ownership of the StoxSmartToken contract. + function acceptSmartTokenOwnership() external onlyOwner { + stox.acceptOwnership(); + } + + /// @dev Proposes to transfer control of the Trustee contract to a new owner. + /// @param _newOwnerCandidate address The address to transfer ownership to. + /// + /// Note that: + /// 1. The new owner will need to call Trustee's acceptOwnership directly in order to accept the ownership. + /// 2. Calling this method during the token sale won't be possible, as the Trustee is only created after its + /// finalization. + function transferTrusteeOwnership(address _newOwnerCandidate) external onlyOwner { + trustee.transferOwnership(_newOwnerCandidate); + } + + /// @dev Accepts new ownership on behalf of the Trustee contract. This can be used, by the token sale + /// contract itself to claim back ownership of the Trustee contract. + function acceptTrusteeOwnership() external onlyOwner { + trustee.acceptOwnership(); + } +} \ No newline at end of file diff --git a/utils/slither_format/tests/real_world/0x0235fe624e044a05eed7a43e16e3083bc8a4287a_OriginalToken.sol b/utils/slither_format/tests/real_world/0x0235fe624e044a05eed7a43e16e3083bc8a4287a_OriginalToken.sol new file mode 100644 index 000000000..2f7283ff0 --- /dev/null +++ b/utils/slither_format/tests/real_world/0x0235fe624e044a05eed7a43e16e3083bc8a4287a_OriginalToken.sol @@ -0,0 +1,241 @@ +pragma solidity ^0.4.17; + +contract Cofounded { + mapping (address => uint) public cofounderIndices; + address[] public cofounders; + + + /// @dev restrict execution to one of original cofounder addresses + modifier restricted () { + uint cofounderIndex = cofounderIndices[msg.sender]; + require(msg.sender == cofounders[cofounderIndex]); + _; + } + + /// @notice creates the Cofounded contract instance + /// @dev adds up to cofounders. + /// also adds the deployment address as a cofounder + function Cofounded (address[] contractCofounders) public { + cofounders.push(msg.sender); + + for (uint8 x = 0; x < contractCofounders.length; x++) { + address cofounder = contractCofounders[x]; + + bool isValidUniqueCofounder = + cofounder != address(0) && + cofounder != msg.sender && + cofounderIndices[cofounder] == 0; + + + // NOTE: solidity as of 0.4.20 does not have an + // undefined or null-like value + // thusly mappings return the default value of the value type + // for an unregistered key value + // an address which doesn't exist will return 0 + // which is actually the index of the address of the first + // cofounder + if (isValidUniqueCofounder) { + uint256 cofounderIndex = cofounders.push(cofounder) - 1; + cofounderIndices[cofounder] = cofounderIndex; + } + } + } + + /// @dev get count of cofounders + function getCofounderCount () public constant returns (uint256) { + return cofounders.length; + } + + /// @dev get list of cofounders + function getCofounders () public constant returns (address[]) { + return cofounders; + } +} + +interface ERC20 { + + // Required methods + function transfer (address to, uint256 value) public returns (bool success); + function transferFrom (address from, address to, uint256 value) public returns (bool success); + function approve (address spender, uint256 value) public returns (bool success); + function allowance (address owner, address spender) public constant returns (uint256 remaining); + function balanceOf (address owner) public constant returns (uint256 balance); + // Events + event Transfer (address indexed from, address indexed to, uint256 value); + event Approval (address indexed owner, address indexed spender, uint256 value); +} + + +/// @title Interface for contracts conforming to ERC-165: Pseudo-Introspection, or standard interface detection +/// @author Mish Ochu +interface ERC165 { + /// @dev true iff the interface is supported + function supportsInterface(bytes4 interfaceID) external constant returns (bool); +} +contract InterfaceSignatureConstants { + bytes4 constant InterfaceSignature_ERC165 = + bytes4(keccak256('supportsInterface(bytes4)')); + + bytes4 constant InterfaceSignature_ERC20 = + bytes4(keccak256('totalSupply()')) ^ + bytes4(keccak256('balanceOf(address)')) ^ + bytes4(keccak256('transfer(address,uint256)')) ^ + bytes4(keccak256('transferFrom(address,address,uint256)')) ^ + bytes4(keccak256('approve(address,uint256)')) ^ + bytes4(keccak256('allowance(address,address)')); + + bytes4 constant InterfaceSignature_ERC20_PlusOptions = + bytes4(keccak256('name()')) ^ + bytes4(keccak256('symbol()')) ^ + bytes4(keccak256('decimals()')) ^ + bytes4(keccak256('totalSupply()')) ^ + bytes4(keccak256('balanceOf(address)')) ^ + bytes4(keccak256('transfer(address,uint256)')) ^ + bytes4(keccak256('transferFrom(address,address,uint256)')) ^ + bytes4(keccak256('approve(address,uint256)')) ^ + bytes4(keccak256('allowance(address,address)')); +} + +/// @title an original cofounder based ERC-20 compliant token +/// @author Mish Ochu +/// @dev Ref: https://github.com/ethereum/EIPs/issues/721 +//http://solidity.readthedocs.io/en/develop/contracts.html#arguments-for-base-constructors +contract OriginalToken is Cofounded, ERC20, ERC165, InterfaceSignatureConstants { + bool private hasExecutedCofounderDistribution; + struct Allowance { + uint256 amount; + bool hasBeenPartiallyWithdrawn; + } + + //***** Apparently Optional *****/ + /// @dev returns the name of the token + string public constant name = 'Original Crypto Coin'; + /// @dev returns the symbol of the token (e.g. 'OCC') + string public constant symbol = 'OCC'; + /// @dev returns the number of decimals the tokens use + uint8 public constant decimals = 18; + //**********/ + + /// @dev returns the total token supply + /// @note implemented as a state variable with an automatic (compiler provided) getter + /// instead of a constant (view/readonly) function. + uint256 public totalSupply = 100000000000000000000000000000; + + mapping (address => uint256) public balances; + // TODO: determine if the gas cost for handling the race condition + // (outlined here: https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729) + // is cheaper this way (or this way: https://github.com/Giveth/minime/blob/master/contracts/MiniMeToken.sol#L221-L225) + mapping (address => mapping (address => Allowance)) public allowances; + + /// @dev creates the token + /// NOTE passes tokenCofounders to base contract + /// see Cofounded + function OriginalToken (address[] tokenCofounders, + uint256 cofounderDistribution) Cofounded(tokenCofounders) public { + + if (hasExecutedCofounderDistribution || + cofounderDistribution == 0 || + totalSupply < cofounderDistribution) revert(); + + hasExecutedCofounderDistribution = true; + uint256 initialSupply = totalSupply; + + // divvy up initial token supply accross cofounders + // TODO: ensure each cofounder gets an equal base distribution + + for (uint8 x = 0; x < cofounders.length; x++) { + address cofounder = cofounders[x]; + + initialSupply -= cofounderDistribution; + // there should be some left over for the airdrop campaign + // otherwise don't create this contract + if (initialSupply < cofounderDistribution) revert(); + balances[cofounder] = cofounderDistribution; + } + + balances[msg.sender] += initialSupply; + } + + function transfer (address to, uint256 value) public returns (bool) { + return transferBalance (msg.sender, to, value); + } + + function transferFrom (address from, address to, uint256 value) public returns (bool success) { + Allowance storage allowance = allowances[from][msg.sender]; + if (allowance.amount < value) revert(); + + allowance.hasBeenPartiallyWithdrawn = true; + allowance.amount -= value; + + if (allowance.amount == 0) { + delete allowances[from][msg.sender]; + } + + return transferBalance(from, to, value); + } + + event ApprovalDenied (address indexed owner, address indexed spender); + + // TODO: test with an unintialized Allowance struct + function approve (address spender, uint256 value) public returns (bool success) { + Allowance storage allowance = allowances[msg.sender][spender]; + + if (value == 0) { + delete allowances[msg.sender][spender]; + Approval(msg.sender, spender, value); + return true; + } + + if (allowance.hasBeenPartiallyWithdrawn) { + delete allowances[msg.sender][spender]; + ApprovalDenied(msg.sender, spender); + return false; + } else { + allowance.amount = value; + Approval(msg.sender, spender, value); + } + + return true; + } + + // TODO: compare gas cost estimations between this and https://github.com/ConsenSys/Tokens/blob/master/contracts/eip20/EIP20.sol#L39-L45 + function transferBalance (address from, address to, uint256 value) private returns (bool) { + // don't burn these tokens + if (to == address(0) || from == to) revert(); + // match spec and emit events on 0 value + if (value == 0) { + Transfer(msg.sender, to, value); + return true; + } + + uint256 senderBalance = balances[from]; + uint256 receiverBalance = balances[to]; + if (senderBalance < value) revert(); + senderBalance -= value; + receiverBalance += value; + // overflow check (altough one could use https://github.com/OpenZeppelin/zeppelin-solidity/blob/master/contracts/math/SafeMath.sol) + if (receiverBalance < value) revert(); + + balances[from] = senderBalance; + balances[to] = receiverBalance; + + Transfer(from, to, value); + return true; + } + + + // TODO: test with an unintialized Allowance struct + function allowance (address owner, address spender) public constant returns (uint256 remaining) { + return allowances[owner][spender].amount; + } + + function balanceOf (address owner) public constant returns (uint256 balance) { + return balances[owner]; + } + + function supportsInterface (bytes4 interfaceID) external constant returns (bool) { + return ((interfaceID == InterfaceSignature_ERC165) || + (interfaceID == InterfaceSignature_ERC20) || + (interfaceID == InterfaceSignature_ERC20_PlusOptions)); + } +} \ No newline at end of file diff --git a/utils/slither_format/tests/real_world/0x05f4a42e251f2d52b8ed15e9fedaacfcef1fad27_ZilliqaToken.sol b/utils/slither_format/tests/real_world/0x05f4a42e251f2d52b8ed15e9fedaacfcef1fad27_ZilliqaToken.sol new file mode 100644 index 000000000..5b1869ab0 --- /dev/null +++ b/utils/slither_format/tests/real_world/0x05f4a42e251f2d52b8ed15e9fedaacfcef1fad27_ZilliqaToken.sol @@ -0,0 +1,349 @@ +pragma solidity ^0.4.18; + +/** + * @title ERC20Basic + * @dev Simpler version of ERC20 interface + * @dev see https://github.com/ethereum/EIPs/issues/179 + */ +contract ERC20Basic { + uint256 public totalSupply; + function balanceOf(address who) public view returns (uint256); + function transfer(address to, uint256 value) public returns (bool); + event Transfer(address indexed from, address indexed to, uint256 value); +} + +/** + * @title ERC20 interface + * @dev see https://github.com/ethereum/EIPs/issues/20 + */ +contract ERC20 is ERC20Basic { + function allowance(address owner, address spender) public view returns (uint256); + function transferFrom(address from, address to, uint256 value) public returns (bool); + function approve(address spender, uint256 value) public returns (bool); + event Approval(address indexed owner, address indexed spender, uint256 value); +} + + +/** + * @title SafeMath + * @dev Math operations with safety checks that throw on error + */ +library SafeMath { + function mul(uint256 a, uint256 b) internal pure returns (uint256) { + if (a == 0) { + return 0; + } + uint256 c = a * b; + assert(c / a == b); + return c; + } + + function div(uint256 a, uint256 b) internal pure returns (uint256) { + // assert(b > 0); // Solidity automatically throws when dividing by 0 + uint256 c = a / b; + // assert(a == b * c + a % b); // There is no case in which this doesn't hold + return c; + } + + function sub(uint256 a, uint256 b) internal pure returns (uint256) { + assert(b <= a); + return a - b; + } + + function add(uint256 a, uint256 b) internal pure returns (uint256) { + uint256 c = a + b; + assert(c >= a); + return c; + } +} + + +/** + * @title Basic token + * @dev Basic version of StandardToken, with no allowances. + */ +contract BasicToken is ERC20Basic { + using SafeMath for uint256; + + mapping(address => uint256) balances; + + /** + * @dev transfer token for a specified address + * @param _to The address to transfer to. + * @param _value The amount to be transferred. + */ + function transfer(address _to, uint256 _value) public returns (bool) { + require(_to != address(0)); + require(_value <= balances[msg.sender]); + + // SafeMath.sub will throw if there is not enough balance. + balances[msg.sender] = balances[msg.sender].sub(_value); + balances[_to] = balances[_to].add(_value); + Transfer(msg.sender, _to, _value); + return true; + } + + /** + * @dev Gets the balance of the specified address. + * @param _owner The address to query the the balance of. + * @return An uint256 representing the amount owned by the passed address. + */ + function balanceOf(address _owner) public view returns (uint256 balance) { + return balances[_owner]; + } + +} + +/** + * @title Standard ERC20 token + * + * @dev Implementation of the basic standard token. + * @dev https://github.com/ethereum/EIPs/issues/20 + * @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol + */ +contract StandardToken is ERC20, BasicToken { + + mapping (address => mapping (address => uint256)) internal allowed; + + + /** + * @dev Transfer tokens from one address to another + * @param _from address The address which you want to send tokens from + * @param _to address The address which you want to transfer to + * @param _value uint256 the amount of tokens to be transferred + */ + function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { + require(_to != address(0)); + require(_value <= balances[_from]); + require(_value <= allowed[_from][msg.sender]); + + balances[_from] = balances[_from].sub(_value); + balances[_to] = balances[_to].add(_value); + allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); + Transfer(_from, _to, _value); + return true; + } + + /** + * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender. + * + * Beware that changing an allowance with this method brings the risk that someone may use both the old + * and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this + * race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards: + * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 + * @param _spender The address which will spend the funds. + * @param _value The amount of tokens to be spent. + */ + function approve(address _spender, uint256 _value) public returns (bool) { + allowed[msg.sender][_spender] = _value; + Approval(msg.sender, _spender, _value); + return true; + } + + /** + * @dev Function to check the amount of tokens that an owner allowed to a spender. + * @param _owner address The address which owns the funds. + * @param _spender address The address which will spend the funds. + * @return A uint256 specifying the amount of tokens still available for the spender. + */ + function allowance(address _owner, address _spender) public view returns (uint256) { + return allowed[_owner][_spender]; + } + + /** + * approve should be called when allowed[_spender] == 0. To increment + * allowed value is better to use this function to avoid 2 calls (and wait until + * the first transaction is mined) + * From MonolithDAO Token.sol + */ + function increaseApproval(address _spender, uint _addedValue) public returns (bool) { + allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue); + Approval(msg.sender, _spender, allowed[msg.sender][_spender]); + return true; + } + + function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) { + uint oldValue = allowed[msg.sender][_spender]; + if (_subtractedValue > oldValue) { + allowed[msg.sender][_spender] = 0; + } else { + allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue); + } + Approval(msg.sender, _spender, allowed[msg.sender][_spender]); + return true; + } + +} + +/** + * @title Ownable + * @dev The Ownable contract has an owner address, and provides basic authorization control + * functions, this simplifies the implementation of "user permissions". + */ +contract Ownable { + address public owner; + + + event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); + + + /** + * @dev The Ownable constructor sets the original `owner` of the contract to the sender + * account. + */ + function Ownable() public { + owner = msg.sender; + } + + + /** + * @dev Throws if called by any account other than the owner. + */ + modifier onlyOwner() { + require(msg.sender == owner); + _; + } + + + /** + * @dev Allows the current owner to transfer control of the contract to a newOwner. + * @param newOwner The address to transfer ownership to. + */ + function transferOwnership(address newOwner) public onlyOwner { + require(newOwner != address(0)); + OwnershipTransferred(owner, newOwner); + owner = newOwner; + } + +} + +/** + * @title Pausable + * @dev Base contract which allows children to implement an emergency stop mechanism. + */ +contract Pausable is Ownable { + event PausePublic(bool newState); + event PauseOwnerAdmin(bool newState); + + bool public pausedPublic = true; + bool public pausedOwnerAdmin = false; + + address public admin; + + /** + * @dev Modifier to make a function callable based on pause states. + */ + modifier whenNotPaused() { + if(pausedPublic) { + if(!pausedOwnerAdmin) { + require(msg.sender == admin || msg.sender == owner); + } else { + revert(); + } + } + _; + } + + /** + * @dev called by the owner to set new pause flags + * pausedPublic can't be false while pausedOwnerAdmin is true + */ + function pause(bool newPausedPublic, bool newPausedOwnerAdmin) onlyOwner public { + require(!(newPausedPublic == false && newPausedOwnerAdmin == true)); + + pausedPublic = newPausedPublic; + pausedOwnerAdmin = newPausedOwnerAdmin; + + PausePublic(newPausedPublic); + PauseOwnerAdmin(newPausedOwnerAdmin); + } +} + +contract PausableToken is StandardToken, Pausable { + + function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) { + return super.transfer(_to, _value); + } + + function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) { + return super.transferFrom(_from, _to, _value); + } + + function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) { + return super.approve(_spender, _value); + } + + function increaseApproval(address _spender, uint _addedValue) public whenNotPaused returns (bool success) { + return super.increaseApproval(_spender, _addedValue); + } + + function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused returns (bool success) { + return super.decreaseApproval(_spender, _subtractedValue); + } +} + + +contract ZilliqaToken is PausableToken { + string public constant name = "Zilliqa"; + string public constant symbol = "ZIL"; + uint8 public constant decimals = 12; + + modifier validDestination( address to ) + { + require(to != address(0x0)); + require(to != address(this)); + _; + } + + function ZilliqaToken( address _admin, uint _totalTokenAmount ) + { + // assign the admin account + admin = _admin; + + // assign the total tokens to zilliqa + totalSupply = _totalTokenAmount; + balances[msg.sender] = _totalTokenAmount; + Transfer(address(0x0), msg.sender, _totalTokenAmount); + } + + function transfer(address _to, uint _value) validDestination(_to) returns (bool) + { + return super.transfer(_to, _value); + } + + function transferFrom(address _from, address _to, uint _value) validDestination(_to) returns (bool) + { + return super.transferFrom(_from, _to, _value); + } + + event Burn(address indexed _burner, uint _value); + + function burn(uint _value) returns (bool) + { + balances[msg.sender] = balances[msg.sender].sub(_value); + totalSupply = totalSupply.sub(_value); + Burn(msg.sender, _value); + Transfer(msg.sender, address(0x0), _value); + return true; + } + + // save some gas by making only one contract call + function burnFrom(address _from, uint256 _value) returns (bool) + { + assert( transferFrom( _from, msg.sender, _value ) ); + return burn(_value); + } + + function emergencyERC20Drain( ERC20 token, uint amount ) onlyOwner { + // owner can drain tokens that are sent here by mistake + token.transfer( owner, amount ); + } + + event AdminTransferred(address indexed previousAdmin, address indexed newAdmin); + + function changeAdmin(address newAdmin) onlyOwner { + // owner can re-assign the admin + AdminTransferred(admin, newAdmin); + admin = newAdmin; + } +} \ No newline at end of file diff --git a/utils/slither_format/tests/run_all_tests.py b/utils/slither_format/tests/run_all_tests.py new file mode 100644 index 000000000..935de5408 --- /dev/null +++ b/utils/slither_format/tests/run_all_tests.py @@ -0,0 +1,17 @@ +import subprocess + +p1 = subprocess.Popen(['python3', './slither_format/tests/test_constable_states.py']) +p1.wait() +p2 = subprocess.Popen(['python3', './slither_format/tests/test_constant_function.py']) +p2.wait() +p3 = subprocess.Popen(['python3', './slither_format/tests/test_external_function.py']) +p3.wait() +p4 = subprocess.Popen(['python3', './slither_format/tests/test_unused_state_vars.py']) +p4.wait() +p5 = subprocess.Popen(['python3', './slither_format/tests/test_naming_convention.py']) +p5.wait() +p6 = subprocess.Popen(['python3', './slither_format/tests/test_pragma.py']) +p6.wait() +p7 = subprocess.Popen(['python3', './slither_format/tests/test_solc_version.py']) +p7.wait() + diff --git a/utils/slither_format/tests/test_constable_states.py b/utils/slither_format/tests/test_constable_states.py new file mode 100644 index 000000000..cd4d1891b --- /dev/null +++ b/utils/slither_format/tests/test_constable_states.py @@ -0,0 +1,57 @@ +import unittest +import subprocess, os, sys + +class TestConstableState(unittest.TestCase): + testDataFile = "const_state_variables.sol" + testDataDir = "./slither_format/tests/test_data/" + testFilePath = testDataDir+testDataFile + + def setUp(self): + outFD = open(self.testFilePath+".out","w") + errFD = open(self.testFilePath+".err","w") + p = subprocess.Popen(['python3', '-m', 'slither_format','--verbose','--detect','constable-states',self.testFilePath], stdout=outFD,stderr=errFD) + p.wait() + outFD.close() + errFD.close() + + def tearDown(self): + p = subprocess.Popen(['rm','-f',self.testFilePath+'.out',self.testFilePath+'.err',self.testFilePath+'.format']) + p.wait() + + def test_constable_states(self): + outFD = open(self.testFilePath+".out","r") + outFD_lines = outFD.readlines() + for i in range(len(outFD_lines)): + outFD_lines[i] = outFD_lines[i].strip() + self.assertTrue(os.path.isfile(self.testFilePath+".format"),"Patched .format file is not created?!") + self.assertEqual(outFD_lines[0].rstrip(),"Number of Slither results: 6") + self.assertEqual(outFD_lines[1].rstrip(),"Number of patches: 6") + self.assertEqual(outFD_lines.count("Detector: constable-states"), 6) + self.assertEqual(outFD_lines.count("Old string: address public myFriendsAddress = 0xc0ffee254729296a45a3885639AC7E10F9d54979"), 1) + self.assertEqual(outFD_lines.count("New string: address public constant myFriendsAddress = 0xc0ffee254729296a45a3885639AC7E10F9d54979"), 1) + self.assertEqual(outFD_lines.count("Location start: 132"), 1) + self.assertEqual(outFD_lines.count("Location end: 208"), 1) + self.assertEqual(outFD_lines.count("Old string: uint public test = 5"), 1) + self.assertEqual(outFD_lines.count("New string: uint public constant test = 5"), 1) + self.assertEqual(outFD_lines.count("Location start: 237"), 1) + self.assertEqual(outFD_lines.count("Location end: 257"), 1) + self.assertEqual(outFD_lines.count("Old string: string text2 = \"xyz\""), 1) + self.assertEqual(outFD_lines.count("New string: string constant text2 = \"xyz\""), 1) + self.assertEqual(outFD_lines.count("Location start: 333"), 1) + self.assertEqual(outFD_lines.count("Location end: 353"), 1) + self.assertEqual(outFD_lines.count("Old string: address public mySistersAddress = 0x999999cf1046e68e36E1aA2E0E07105eDDD1f08E"), 1) + self.assertEqual(outFD_lines.count("New string: address public constant mySistersAddress = 0x999999cf1046e68e36E1aA2E0E07105eDDD1f08E"), 1) + self.assertEqual(outFD_lines.count("Location start: 496"), 1) + self.assertEqual(outFD_lines.count("Location end: 572"), 1) + self.assertEqual(outFD_lines.count("Old string: bytes32 should_be_constant = sha256('abc')"), 1) + self.assertEqual(outFD_lines.count("New string: bytes32 constant should_be_constant = sha256('abc')"), 1) + self.assertEqual(outFD_lines.count("Location start: 793"), 1) + self.assertEqual(outFD_lines.count("Location end: 835"), 1) + self.assertEqual(outFD_lines.count("Old string: uint should_be_constant_2 = A + 1"), 1) + self.assertEqual(outFD_lines.count("New string: uint constant should_be_constant_2 = A + 1"), 1) + self.assertEqual(outFD_lines.count("Location start: 841"), 1) + self.assertEqual(outFD_lines.count("Location end: 874"), 1) + outFD.close() + +if __name__ == '__main__': + unittest.main() diff --git a/utils/slither_format/tests/test_constant_function.py b/utils/slither_format/tests/test_constant_function.py new file mode 100644 index 000000000..8d43a0f55 --- /dev/null +++ b/utils/slither_format/tests/test_constant_function.py @@ -0,0 +1,65 @@ +import unittest +import subprocess, os, sys + +class TestConstantFunctions(unittest.TestCase): + testDataFile1 = "constant.sol" + testDataFile2 = "constant-0.5.1.sol" + testDataDir = "./slither_format/tests/test_data/" + testFilePath1 = testDataDir+testDataFile1 + testFilePath2 = testDataDir+testDataFile2 + + def setUp(self): + outFD1 = open(self.testFilePath1+".out","w") + errFD1 = open(self.testFilePath1+".err","w") + p1 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose','--detect','constant-function',self.testFilePath1], stdout=outFD1,stderr=errFD1) + p1.wait() + outFD2 = open(self.testFilePath2+".out","w") + errFD2 = open(self.testFilePath2+".err","w") + p2 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose','--detect','constant-function',self.testFilePath2], stdout=outFD2,stderr=errFD2) + p2.wait() + outFD1.close() + errFD1.close() + outFD2.close() + errFD2.close() + + def tearDown(self): + p1 = subprocess.Popen(['rm','-f',self.testFilePath1+'.out',self.testFilePath1+'.err',self.testFilePath1+'.format']) + p1.wait() + p2 = subprocess.Popen(['rm','-f',self.testFilePath2+'.out',self.testFilePath2+'.err',self.testFilePath2+'.format']) + p2.wait() + + def test_constant_function(self): + outFD1 = open(self.testFilePath1+".out","r") + outFD1_lines = outFD1.readlines() + for i in range(len(outFD1_lines)): + outFD1_lines[i] = outFD1_lines[i].strip() + self.assertTrue(os.path.isfile(self.testFilePath1+".format"),"Patched .format file is not created?!") + self.assertEqual(outFD1_lines[0],"Number of Slither results: 3") + self.assertEqual(outFD1_lines[1],"Number of patches: 3") + self.assertEqual(outFD1_lines.count("Detector: constant-function"), 3) + self.assertEqual(outFD1_lines.count("Old string: () public view"), 2) + self.assertEqual(outFD1_lines.count("Old string: () public constant"), 1) + self.assertEqual(outFD1_lines.count("New string: () public"), 3) + self.assertEqual(outFD1_lines.count("Location start: 67"), 1) + self.assertEqual(outFD1_lines.count("Location end: 81"), 1) + self.assertEqual(outFD1_lines.count("Location start: 139"), 1) + self.assertEqual(outFD1_lines.count("Location end: 157"), 1) + self.assertEqual(outFD1_lines.count("Location start: 350"), 1) + self.assertEqual(outFD1_lines.count("Location end: 364"), 1) + outFD1.close() + + outFD2 = open(self.testFilePath2+".out","r") + outFD2_lines = outFD2.readlines() + for i in range(len(outFD2_lines)): + outFD2_lines[i] = outFD2_lines[i].strip() + self.assertTrue(os.path.isfile(self.testFilePath2+".format"),"Patched .format file is not created?!") + self.assertEqual(outFD2_lines[0],"Number of Slither results: 1") + self.assertEqual(outFD2_lines[1],"Number of patches: 1") + self.assertEqual(outFD2_lines.count("Old string: () public view"), 1) + self.assertEqual(outFD2_lines.count("New string: () public"), 1) + self.assertEqual(outFD2_lines.count("Location start: 211"), 1) + self.assertEqual(outFD2_lines.count("Location end: 225"), 1) + outFD2.close() + +if __name__ == '__main__': + unittest.main() diff --git a/utils/slither_format/tests/test_data/const_state_variables.sol b/utils/slither_format/tests/test_data/const_state_variables.sol new file mode 100644 index 000000000..aed05d97f --- /dev/null +++ b/utils/slither_format/tests/test_data/const_state_variables.sol @@ -0,0 +1,52 @@ +//pragma solidity ^0.4.24; + + +contract A { + + address constant public MY_ADDRESS = 0xE0f5206BBD039e7b0592d8918820024e2a7437b9; + address public myFriendsAddress = 0xc0ffee254729296a45a3885639AC7E10F9d54979; + + uint public used; + uint public test = 5; + + uint constant X = 32**22 + 8; + string constant TEXT1 = "abc"; + string text2 = "xyz"; + + function setUsed() public { + if (msg.sender == MY_ADDRESS) { + used = test; + } + } +} + + +contract B is A { + + address public mySistersAddress = 0x999999cf1046e68e36E1aA2E0E07105eDDD1f08E; + + function () external { + used = 0; + } + + function setUsed(uint a) public { + if (msg.sender == MY_ADDRESS) { + used = a; + } + } +} + +contract MyConc{ + + uint constant A = 1; + bytes32 should_be_constant = sha256('abc'); + uint should_be_constant_2 = A + 1; + address not_constant = msg.sender; + uint not_constant_2 = getNumber(); + uint not_constant_3 = 10 + block.number; + + function getNumber() public returns(uint){ + return block.number; + } + +} diff --git a/utils/slither_format/tests/test_data/constant-0.5.1.sol b/utils/slither_format/tests/test_data/constant-0.5.1.sol new file mode 100644 index 000000000..3293ab45d --- /dev/null +++ b/utils/slither_format/tests/test_data/constant-0.5.1.sol @@ -0,0 +1,18 @@ +contract Constant { + + uint a; + + + function test_view_shadow() public view{ + uint a; + a = 0; + } + + function test_view() public view{ + a; + } + + function test_assembly_bug() public view{ + assembly{} + } +} diff --git a/utils/slither_format/tests/test_data/constant.sol b/utils/slither_format/tests/test_data/constant.sol new file mode 100644 index 000000000..934634803 --- /dev/null +++ b/utils/slither_format/tests/test_data/constant.sol @@ -0,0 +1,25 @@ +contract Constant { + + uint a; + + function test_view_bug() public view{ + a = 0; + } + + function test_constant_bug() public constant{ + a = 0; + } + + function test_view_shadow() public view{ + uint a; + a = 0; + } + + function test_view() public view{ + a; + } + + function test_assembly_bug() public view{ + assembly{} + } +} diff --git a/utils/slither_format/tests/test_data/external_function.sol b/utils/slither_format/tests/test_data/external_function.sol new file mode 100644 index 000000000..efaf18e3d --- /dev/null +++ b/utils/slither_format/tests/test_data/external_function.sol @@ -0,0 +1,101 @@ +//pragma solidity ^0.4.24; + +import "./external_function_import.sol"; + +contract ContractWithFunctionCalledSuper is ContractWithFunctionCalled { + function callWithSuper() public { + uint256 i = 0; + } +} + +contract ContractWithFunctionNotCalled { + + modifier mod (uint c) { + require (c > 0); + _; + } + + // With parameter and return + function funcNotCalled5(uint _i) + public returns (uint) { + return(_i + 10); + } + + // With no visibility specifier which is ok until solc 0.5.0 + function funcNotCalled4() { + } + + function funcNotCalled3() public + returns (uint a) + { + a = 100; + } + + function funcNotCalled2() public { + } + + function funcNotCalled() public { + } + + function my_func() internal returns(bool) { + return true; + } + + /* Cannot be converted to external because parameter i is written to in function and so cannot be in calldata */ + function test4(uint i) public returns(uint){ + i += 1; + return(i); + } + + /* public with modifier */ + function test5(uint number) public mod (number) returns(uint){ + return(number); + } + + /* implicit with modifier */ + function test6(uint number) mod (number) returns(uint){ + return(number); + } + +} + +contract ContractWithFunctionNotCalled2 is ContractWithFunctionCalledSuper { + function funcNotCalled() public { + uint256 i = 0; + address three = address(new ContractWithFunctionNotCalled()); + three.call(abi.encode(bytes4(keccak256("helloTwo()")))); + super.callWithSuper(); + ContractWithFunctionCalled c = new ContractWithFunctionCalled(); + c.funcCalled(); + } +} + +contract InternalCall { + + function() returns(uint) ptr; + + function set_test1() external{ + ptr = test1; + } + + function set_test2() external{ + ptr = test2; + } + + function test1() public returns(uint){ + return 1; + } + + function test2() public returns(uint){ + return 2; + } + + function test3() public returns(uint){ + return 3; + } + + function exec() external returns(uint){ + return ptr(); + } + +} diff --git a/utils/slither_format/tests/test_data/external_function_2.sol b/utils/slither_format/tests/test_data/external_function_2.sol new file mode 100644 index 000000000..97eed10a0 --- /dev/null +++ b/utils/slither_format/tests/test_data/external_function_2.sol @@ -0,0 +1,55 @@ +// This tests against false-positives. This test should output no recommendations from the external-function detector. + + +contract ContractWithBaseFunctionCalled { + function getsCalledByBase() public; + function callsOverrideMe() external { + getsCalledByBase(); + } +} + + +contract DerivingContractWithBaseCalled is ContractWithBaseFunctionCalled { + function getsCalledByBase() public { + // This should not be recommended to be marked external because it is called by the base class. + } +} + + +// All the contracts below should not recommend changing to external since inherited contracts have dynamic calls. +contract ContractWithDynamicCall { + function() returns(uint) ptr; + + function test1() public returns(uint){ + return 1; + } + + function test2() public returns(uint){ + return 2; + } + + function setTest1() external{ + ptr = test1; + } + + function setTest2() external{ + ptr = test2; + } + + function exec() external returns(uint){ + return ptr(); + } +} + +contract DerivesFromDynamicCall is ContractWithDynamicCall{ + function getsCalledDynamically() public returns (uint){ + // This should not be recommended because it is called dynamically. + return 3; + } + function setTest3() public { + // This should not be recommended because we inherit from a contract that calls dynamically, and we cannot be + // sure it did not somehow call this function. + + ptr = getsCalledDynamically; + } +} diff --git a/utils/slither_format/tests/test_data/external_function_import.sol b/utils/slither_format/tests/test_data/external_function_import.sol new file mode 100644 index 000000000..efddea28e --- /dev/null +++ b/utils/slither_format/tests/test_data/external_function_import.sol @@ -0,0 +1,7 @@ +// This file is imported by external_function.sol + +contract ContractWithFunctionCalled { + function funcCalled() external { + uint256 i = 0; + } +} diff --git a/utils/slither_format/tests/test_data/naming_convention.sol b/utils/slither_format/tests/test_data/naming_convention.sol new file mode 100644 index 000000000..422788344 --- /dev/null +++ b/utils/slither_format/tests/test_data/naming_convention.sol @@ -0,0 +1,108 @@ +//pragma solidity ^0.4.24; + +contract naming { + + enum Numbers {ONE, TWO} + enum numbers {ONE, TWO} + + numbers nums = numbers.TWO; + + uint constant MY_CONSTANT = 1; + uint constant MY_other_CONSTANT = 2; + + uint Var_One = 1; uint varTwo = 2; + + struct test { + uint a; + } + + struct Test { + uint a; + } + + test t; + + event Event_(uint); + event event_(uint); + + uint Number2; + + function getOne(bytes32 b) view public returns(uint) { + return MY_other_CONSTANT; + } + + function getOne(uint i) view public returns(numbers) { + numbers num; + num = numbers.ONE; + return(num); + } + + function getOne() view public returns(uint) + { + uint naming; + naming = GetOne(naming); + event_(naming); + return 1; + } + + function GetOne(uint i) view public returns (uint) + { + return (1 + Number2); + } + + function setInt(uint number1, uint Number2) public + { + uint i = number1 + Number2; + } + + + modifier CantDo() { + _; + } + + modifier canDo() { + _; + } +} + +contract Test { + naming n; + + function foo() { + n.GetOne(10); + } +} + +contract T { + uint private _myPrivateVar; + uint _myPublicVar; + + modifier ModifierTest() { + _; + } + + modifier modifierTestContractTypes(naming m1) { + naming m2; + _; + } + + function functionTestModifier(uint i) public ModifierTest returns(uint) { + return _myPrivateVar; + } + + function functionTestContractTypes(naming n1) public returns(naming) { + naming n2; + return(n2); + } + + function test(uint _unused, uint _used) public returns(uint){ + return _used; + } + + + uint k = 1; + + uint constant M = 1; + + uint l = 1; +} diff --git a/utils/slither_format/tests/test_data/naming_convention_contract.sol b/utils/slither_format/tests/test_data/naming_convention_contract.sol new file mode 100644 index 000000000..52349410b --- /dev/null +++ b/utils/slither_format/tests/test_data/naming_convention_contract.sol @@ -0,0 +1,51 @@ +pragma solidity ^0.4.24; + +/* contract definitione */ +contract one { + /* contract declaration as state variable */ + three k; + + function foo(uint i) { + /* contract declaration as local variable */ + three l; + l.foo(10); + k.foo(10); + } +} + +/* contract definitione */ +contract Two { + /* contract declaration as state variable */ + one m; + + function foo() { + /* contract declaration as local variable */ + one n; + n.foo(10); + m.foo(100); + } + +} + +/* contract definitione */ +contract three { + /* contract declaration as state variable */ + Two o; + + /* contract as function return value */ + function foo(uint i) returns (one) { + /* contract declaration as local variable */ + Two p; + p.foo(); + o.foo(); + /* new contract object */ + one r = new one(); + return(r); + } + + /* contract as function parameter */ + function foobar(one q) { + q.foo(10); + } +} + diff --git a/utils/slither_format/tests/test_data/naming_convention_enum.sol b/utils/slither_format/tests/test_data/naming_convention_enum.sol new file mode 100644 index 000000000..386be0c3d --- /dev/null +++ b/utils/slither_format/tests/test_data/naming_convention_enum.sol @@ -0,0 +1,46 @@ +pragma solidity ^0.4.24; + +contract A { + + /* enum definition - bad */ + enum e {ONE, TWO} + + /* enum declaration - bad */ + e e1; + + function foo() { + /* enum use - bad */ + e1 = e.ONE; + } +} + +contract B { + + /* enum definition - good */ + enum E {ONE, TWO} + + /* enum definition - good */ + E e1; + + function foo() { + /* enum use - good */ + e1 = E.ONE; + } + +} + +contract C { + + /* enum definition - bad */ + enum e {ONE, TWO} + + /* enum declaration - bad */ + e e1; + + /* enum as parameter and return value - bad */ + function foo(e eA) returns (e) { + e e2 = eA; + return (e2); + } +} + diff --git a/utils/slither_format/tests/test_data/naming_convention_event.sol b/utils/slither_format/tests/test_data/naming_convention_event.sol new file mode 100644 index 000000000..9616bb634 --- /dev/null +++ b/utils/slither_format/tests/test_data/naming_convention_event.sol @@ -0,0 +1,34 @@ +pragma solidity ^0.4.24; + +contract One { + /* event declaration - bad */ + event e(uint); + + function foo(uint i) { + /* event call - bad */ + e(i); + } +} + +contract Two { + /* event declaration - good */ + event E(uint); + + function foo(uint i) { + /* event call - good */ + E(i); + } + +} + +contract Three { + /* event declaration - bad */ + event e(uint); + + function foo(uint i) { + /* event call with emit - bad */ + emit e(i); + } + +} + diff --git a/utils/slither_format/tests/test_data/naming_convention_function.sol b/utils/slither_format/tests/test_data/naming_convention_function.sol new file mode 100644 index 000000000..042905112 --- /dev/null +++ b/utils/slither_format/tests/test_data/naming_convention_function.sol @@ -0,0 +1,33 @@ +pragma solidity ^0.4.24; + +contract A { + + /* function definition - bad */ + function Foo() { + /* function call - bad */ + uint i = Foobar(10); + } + + /* function definition - bad */ + function Foobar(uint i) returns (uint) { + return (1+10); + } + +} + +contract B { + /* function definition - good */ + function foo() { + /* function call - good */ + uint i = foobar(10); + } + + /* function definition - good */ + function foobar(uint i) returns (uint) { + A a; + /* function call - bad */ + return (a.Foobar(10) + i); + } +} + + diff --git a/utils/slither_format/tests/test_data/naming_convention_modifier.sol b/utils/slither_format/tests/test_data/naming_convention_modifier.sol new file mode 100644 index 000000000..1e658c9a8 --- /dev/null +++ b/utils/slither_format/tests/test_data/naming_convention_modifier.sol @@ -0,0 +1,47 @@ +pragma solidity ^0.4.24; + +contract A { + + /* modifier definition - good */ + modifier one() { + _; + } + + /* modifier use - good */ + function foo() one { + } +} + +contract B { + /* modifier definition - bad */ + modifier One() { + _; + } + + /* modifier use - bad */ + function foo () One { + } + +} + +contract C { + + /* modifier definition - good */ + modifier one() { + _; + } + + /* modifier definition - bad */ + modifier Two() { + _; + } + + /* modifier uses - good and bad */ + function foo() one Two returns (uint) { + /* Local variable with same name as bad modifier name from contract B */ + uint One; + return(One); + } + +} + diff --git a/utils/slither_format/tests/test_data/naming_convention_parameter.sol b/utils/slither_format/tests/test_data/naming_convention_parameter.sol new file mode 100644 index 000000000..de0719177 --- /dev/null +++ b/utils/slither_format/tests/test_data/naming_convention_parameter.sol @@ -0,0 +1,47 @@ +pragma solidity ^0.4.24; + +contract A { + + /* parameter declaration - bad */ + function foo(uint Count) { + /* parameter use - bad */ + uint i = Count; + } + + /* parameter declarations - bad */ + function foobar(uint Count, uint Number) returns (uint) { + /* parameter declarations - bad */ + return (Count+Number); + } + + modifier mod (uint c) { + require (c > 100); + _; + } + + /* parameter declarations - bad */ + /* function parameter passed to modifier */ + function bar(uint Count) mod (Count) returns(uint) { + /* parameter declarations - bad */ + return (Count); + } + +} + + +contract B { + + mapping(address => uint256) balances; + + /* parameter declarations - bad */ + function bar(address _to, address _from) returns (uint){ + uint i; + /* parameter use - bad */ + i = balances[_to]; + /* parameter use - bad */ + balances[_from] = 100; + return(i); + } +} + + diff --git a/utils/slither_format/tests/test_data/naming_convention_state_variable.sol b/utils/slither_format/tests/test_data/naming_convention_state_variable.sol new file mode 100644 index 000000000..449fcb2db --- /dev/null +++ b/utils/slither_format/tests/test_data/naming_convention_state_variable.sol @@ -0,0 +1,30 @@ +pragma solidity ^0.4.24; + +contract A { + /* State variable declaration constant - good */ + uint constant NUMBER = 100; + /* State variable declaration private - good */ + uint private count = 100; + /* State variable declaration non-constant non-private - good */ + uint maxnum = 999; + + function foo() { + /* State variable uses - good */ + uint i = NUMBER + count + maxnum; + } +} + +contract B { + /* State variable declaration constant - bad */ + uint constant number = 100; + /* State variable declaration private - bad */ + uint private Count = 100; + /* State variable declaration non-constant non-private - good */ + uint Maxnum = 999; + function foo() { + /* State variable uses - bad */ + uint i = number + Count + Maxnum; + Count += i; + } +} + diff --git a/utils/slither_format/tests/test_data/naming_convention_structure.sol b/utils/slither_format/tests/test_data/naming_convention_structure.sol new file mode 100644 index 000000000..79886ba91 --- /dev/null +++ b/utils/slither_format/tests/test_data/naming_convention_structure.sol @@ -0,0 +1,51 @@ +pragma solidity ^0.4.24; +pragma experimental ABIEncoderV2; + +contract A { + + /* struct definition - bad */ + struct s { + uint i; + } + + /* struct declaration - bad */ + s s1; + + function foo() { + s1.i = 10; + } +} + +contract B { + + /* struct definition - good */ + struct S { + uint i; + } + + /* struct definition - good */ + S s1; + + function foo() { + s1.i = 10; + } + +} + +contract C { + + /* struct definition - bad */ + struct s { + uint i; + } + + /* struct declaration - bad */ + s s1; + + /* struct as parameter and return value - bad */ + function foo(s sA) returns (s) { + s1.i = sA.i; + return (s1); + } +} + diff --git a/utils/slither_format/tests/test_data/pragma.0.4.23.sol b/utils/slither_format/tests/test_data/pragma.0.4.23.sol new file mode 100644 index 000000000..6e6a5000f --- /dev/null +++ b/utils/slither_format/tests/test_data/pragma.0.4.23.sol @@ -0,0 +1 @@ +pragma solidity ^0.4.23; diff --git a/utils/slither_format/tests/test_data/pragma.0.4.24.sol b/utils/slither_format/tests/test_data/pragma.0.4.24.sol new file mode 100644 index 000000000..c10357dcc --- /dev/null +++ b/utils/slither_format/tests/test_data/pragma.0.4.24.sol @@ -0,0 +1,5 @@ +pragma solidity ^0.4.24; + +import "./pragma.0.4.23.sol"; + +contract Test{} diff --git a/utils/slither_format/tests/test_data/pragma.0.5.2.sol b/utils/slither_format/tests/test_data/pragma.0.5.2.sol new file mode 100644 index 000000000..00fff9302 --- /dev/null +++ b/utils/slither_format/tests/test_data/pragma.0.5.2.sol @@ -0,0 +1 @@ +pragma solidity ^0.5.2; diff --git a/utils/slither_format/tests/test_data/pragma.0.5.4.sol b/utils/slither_format/tests/test_data/pragma.0.5.4.sol new file mode 100644 index 000000000..16297788e --- /dev/null +++ b/utils/slither_format/tests/test_data/pragma.0.5.4.sol @@ -0,0 +1,5 @@ +pragma solidity ^0.5.4; + +import "./pragma.0.5.2.sol"; + +contract Test{} diff --git a/utils/slither_format/tests/test_data/solc_version_incorrect1.sol b/utils/slither_format/tests/test_data/solc_version_incorrect1.sol new file mode 100644 index 000000000..1c517b087 --- /dev/null +++ b/utils/slither_format/tests/test_data/solc_version_incorrect1.sol @@ -0,0 +1,5 @@ +// The version pragma below should get flagged by the detector +pragma solidity ^0.4.23; +contract Contract{ + +} diff --git a/utils/slither_format/tests/test_data/solc_version_incorrect2.sol b/utils/slither_format/tests/test_data/solc_version_incorrect2.sol new file mode 100644 index 000000000..a29d1a18d --- /dev/null +++ b/utils/slither_format/tests/test_data/solc_version_incorrect2.sol @@ -0,0 +1,5 @@ +// The version pragma below should get flagged by the detector +pragma solidity >=0.4.0 <0.6.0; +contract Contract{ + +} diff --git a/utils/slither_format/tests/test_data/solc_version_incorrect3.sol b/utils/slither_format/tests/test_data/solc_version_incorrect3.sol new file mode 100644 index 000000000..912616455 --- /dev/null +++ b/utils/slither_format/tests/test_data/solc_version_incorrect3.sol @@ -0,0 +1,5 @@ +// The version pragma below should get flagged by the detector +pragma solidity >=0.4.0 <0.4.25; +contract Contract{ + +} diff --git a/utils/slither_format/tests/test_data/solc_version_incorrect4.sol b/utils/slither_format/tests/test_data/solc_version_incorrect4.sol new file mode 100644 index 000000000..b93d43e93 --- /dev/null +++ b/utils/slither_format/tests/test_data/solc_version_incorrect4.sol @@ -0,0 +1,5 @@ +// The version pragma below should get flagged by the detector +pragma solidity ^0.5.1; +contract Contract{ + +} diff --git a/utils/slither_format/tests/test_data/unused_state.sol b/utils/slither_format/tests/test_data/unused_state.sol new file mode 100644 index 000000000..50319c158 --- /dev/null +++ b/utils/slither_format/tests/test_data/unused_state.sol @@ -0,0 +1,13 @@ +//pragma solidity ^0.4.24; + +contract A{ + address unused ; + address used; +} + +contract B is A{ + + function () external{ + used = address(0); + } +} diff --git a/utils/slither_format/tests/test_external_function.py b/utils/slither_format/tests/test_external_function.py new file mode 100644 index 000000000..b5d5c55b8 --- /dev/null +++ b/utils/slither_format/tests/test_external_function.py @@ -0,0 +1,79 @@ +import unittest +import subprocess, os, sys + +class TestExternalFunctions(unittest.TestCase): + testDataFile1 = "external_function.sol" + testDataFile2 = "external_function_2.sol" + testDataDir = "./slither_format/tests/test_data/" + testFilePath1 = testDataDir+testDataFile1 + testFilePath2 = testDataDir+testDataFile2 + + def setUp(self): + outFD1 = open(self.testFilePath1+".out","w") + errFD1 = open(self.testFilePath1+".err","w") + p1 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose','--detect','external-function',self.testFilePath1], stdout=outFD1,stderr=errFD1) + p1.wait() + outFD2 = open(self.testFilePath2+".out","w") + errFD2 = open(self.testFilePath2+".err","w") + p2 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose','--detect','external-function',self.testFilePath2], stdout=outFD2,stderr=errFD2) + p2.wait() + outFD1.close() + errFD1.close() + outFD2.close() + errFD2.close() + + def tearDown(self): + p1 = subprocess.Popen(['rm','-f',self.testFilePath1+'.out',self.testFilePath1+'.err',self.testFilePath1+'.format']) + p1.wait() + p2 = subprocess.Popen(['rm','-f',self.testFilePath2+'.out',self.testFilePath2+'.err',self.testFilePath2+'.format']) + p2.wait() + + def test_external_function(self): + outFD1 = open(self.testFilePath1+".out","r") + outFD1_lines = outFD1.readlines() + for i in range(len(outFD1_lines)): + outFD1_lines[i] = outFD1_lines[i].strip() + self.assertTrue(os.path.isfile(self.testFilePath1+".format"),"Patched .format file is not created?!") + self.assertEqual(outFD1_lines[0],"Number of Slither results: 9") + self.assertEqual(outFD1_lines[1],"Number of patches: 8") + self.assertEqual(outFD1_lines.count("Detector: external-function"), 8) + self.assertEqual(outFD1_lines.count("Old string: public returns"), 1) + self.assertEqual(outFD1_lines.count("New string: external returns"), 1) + self.assertEqual(outFD1_lines.count("Location start: 384"), 1) + self.assertEqual(outFD1_lines.count("Location end: 399"), 1) + self.assertEqual(outFD1_lines.count("Old string:"), 1) + self.assertEqual(outFD1_lines.count("New string: external"), 4) + self.assertEqual(outFD1_lines.count("Location start: 524"), 1) + self.assertEqual(outFD1_lines.count("Location end: 525"), 1) + self.assertEqual(outFD1_lines.count("Old string: public returns"), 1) + self.assertEqual(outFD1_lines.count("New string: external returns"), 1) + self.assertEqual(outFD1_lines.count("Location start: 562"), 1) + self.assertEqual(outFD1_lines.count("Location end: 581"), 1) + self.assertEqual(outFD1_lines.count("Old string: public"), 3) + self.assertEqual(outFD1_lines.count("Old string: public mod"), 1) + self.assertEqual(outFD1_lines.count("New string: external"), 4) + self.assertEqual(outFD1_lines.count("Location start: 642"), 1) + self.assertEqual(outFD1_lines.count("Location end: 649"), 1) + self.assertEqual(outFD1_lines.count("Location start: 685"), 1) + self.assertEqual(outFD1_lines.count("Location end: 692"), 1) + self.assertEqual(outFD1_lines.count("Location start: 1022"), 1) + self.assertEqual(outFD1_lines.count("Location end: 1033"), 1) + self.assertEqual(outFD1_lines.count("Location start: 1142"), 1) + self.assertEqual(outFD1_lines.count("Location end: 1147"), 1) + self.assertEqual(outFD1_lines.count("Old string: mod"), 1) + self.assertEqual(outFD1_lines.count("New string: external mod"), 2) + self.assertEqual(outFD1_lines.count("Location start: 1305"), 1) + self.assertEqual(outFD1_lines.count("Location end: 1312"), 1) + outFD1.close() + + outFD2 = open(self.testFilePath2+".out","r") + outFD2_lines = outFD2.readlines() + for i in range(len(outFD2_lines)): + outFD2_lines[i] = outFD2_lines[i].strip() + self.assertFalse(os.path.isfile(self.testFilePath2+".format"),"Patched .format file _is_ created?!") + self.assertEqual(outFD2_lines[0],"Number of Slither results: 0") + self.assertEqual(outFD2_lines[1],"Number of patches: 0") + outFD2.close() + +if __name__ == '__main__': + unittest.main() diff --git a/utils/slither_format/tests/test_naming_convention.py b/utils/slither_format/tests/test_naming_convention.py new file mode 100644 index 000000000..bd9088b8a --- /dev/null +++ b/utils/slither_format/tests/test_naming_convention.py @@ -0,0 +1,387 @@ +import unittest +import subprocess, os, sys + +class TestNamingConvention(unittest.TestCase): + testDataDir = "./slither_format/tests/test_data/" + testDataFile1 = "naming_convention_contract.sol" + testDataFile2 = "naming_convention_modifier.sol" + testDataFile3 = "naming_convention_structure.sol" + testDataFile4 = "naming_convention_enum.sol" + testDataFile5 = "naming_convention_event.sol" + testDataFile6 = "naming_convention_function.sol" + testDataFile7 = "naming_convention_parameter.sol" + testDataFile8 = "naming_convention_state_variable.sol" + testFilePath1 = testDataDir+testDataFile1 + testFilePath2 = testDataDir+testDataFile2 + testFilePath3 = testDataDir+testDataFile3 + testFilePath4 = testDataDir+testDataFile4 + testFilePath5 = testDataDir+testDataFile5 + testFilePath6 = testDataDir+testDataFile6 + testFilePath7 = testDataDir+testDataFile7 + testFilePath8 = testDataDir+testDataFile8 + + def setUp(self): + outFD1 = open(self.testFilePath1+".out","w") + errFD1 = open(self.testFilePath1+".err","w") + p1 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose','--detect','naming-convention',self.testFilePath1], stdout=outFD1,stderr=errFD1) + p1.wait() + outFD1.close() + errFD1.close() + + outFD2 = open(self.testFilePath2+".out","w") + errFD2 = open(self.testFilePath2+".err","w") + p2 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose','--detect','naming-convention',self.testFilePath2], stdout=outFD2,stderr=errFD2) + p2.wait() + outFD2.close() + errFD2.close() + + outFD3 = open(self.testFilePath3+".out","w") + errFD3 = open(self.testFilePath3+".err","w") + p3 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose','--detect','naming-convention',self.testFilePath3], stdout=outFD3,stderr=errFD3) + p3.wait() + outFD3.close() + errFD3.close() + + outFD4 = open(self.testFilePath4+".out","w") + errFD4 = open(self.testFilePath4+".err","w") + p4 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose','--detect','naming-convention',self.testFilePath4], stdout=outFD4,stderr=errFD4) + p4.wait() + outFD4.close() + errFD4.close() + + outFD5 = open(self.testFilePath5+".out","w") + errFD5 = open(self.testFilePath5+".err","w") + p5 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose','--detect','naming-convention',self.testFilePath5], stdout=outFD5,stderr=errFD5) + p5.wait() + outFD5.close() + errFD5.close() + + outFD6 = open(self.testFilePath6+".out","w") + errFD6 = open(self.testFilePath6+".err","w") + p6 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose','--detect','naming-convention',self.testFilePath6], stdout=outFD6,stderr=errFD6) + p6.wait() + outFD6.close() + errFD6.close() + + outFD7 = open(self.testFilePath7+".out","w") + errFD7 = open(self.testFilePath7+".err","w") + p7 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose','--detect','naming-convention',self.testFilePath7], stdout=outFD7,stderr=errFD7) + p7.wait() + outFD7.close() + errFD7.close() + + outFD8 = open(self.testFilePath8+".out","w") + errFD8 = open(self.testFilePath8+".err","w") + p8 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose','--detect','naming-convention',self.testFilePath8], stdout=outFD8,stderr=errFD8) + p8.wait() + outFD8.close() + errFD8.close() + + def tearDown(self): + p1 = subprocess.Popen(['rm','-f',self.testFilePath1+'.out',self.testFilePath1+'.err',self.testFilePath1+'.format']) + p1.wait() + p2 = subprocess.Popen(['rm','-f',self.testFilePath2+'.out',self.testFilePath2+'.err',self.testFilePath2+'.format']) + p2.wait() + p3 = subprocess.Popen(['rm','-f',self.testFilePath3+'.out',self.testFilePath3+'.err',self.testFilePath3+'.format']) + p3.wait() + p4 = subprocess.Popen(['rm','-f',self.testFilePath4+'.out',self.testFilePath4+'.err',self.testFilePath4+'.format']) + p4.wait() + p5 = subprocess.Popen(['rm','-f',self.testFilePath5+'.out',self.testFilePath5+'.err',self.testFilePath5+'.format']) + p5.wait() + p6 = subprocess.Popen(['rm','-f',self.testFilePath6+'.out',self.testFilePath6+'.err',self.testFilePath6+'.format']) + p6.wait() + p7 = subprocess.Popen(['rm','-f',self.testFilePath7+'.out',self.testFilePath7+'.err',self.testFilePath7+'.format']) + p7.wait() + p8 = subprocess.Popen(['rm','-f',self.testFilePath8+'.out',self.testFilePath8+'.err',self.testFilePath8+'.format']) + p8.wait() + + def test_naming_convention_contract(self): + outFD1 = open(self.testFilePath1+".out","r") + outFD1_lines = outFD1.readlines() + outFD1.close() + for i in range(len(outFD1_lines)): + outFD1_lines[i] = outFD1_lines[i].strip() + self.assertTrue(os.path.isfile(self.testFilePath1+".format"),"Patched .format file is not created?!") + self.assertEqual(outFD1_lines[0],"Number of Slither results: 2") + self.assertEqual(outFD1_lines[1],"Number of patches: 10") + self.assertEqual(outFD1_lines.count("Detector: naming-convention (contract definition)"), 2) + self.assertEqual(outFD1_lines.count("Detector: naming-convention (contract state variable)"), 2) + self.assertEqual(outFD1_lines.count("Detector: naming-convention (contract function variable)"), 5) + self.assertEqual(outFD1_lines.count("Detector: naming-convention (contract new object)"), 1) + self.assertEqual(outFD1_lines.count("Old string: contract one"), 1) + self.assertEqual(outFD1_lines.count("New string: contract One"), 1) + self.assertEqual(outFD1_lines.count("Location start: 53"), 1) + self.assertEqual(outFD1_lines.count("Location end: 65"), 1) + self.assertEqual(outFD1_lines.count("Old string: three k"), 1) + self.assertEqual(outFD1_lines.count("New string: Three k"), 1) + self.assertEqual(outFD1_lines.count("Location start: 117"), 1) + self.assertEqual(outFD1_lines.count("Location end: 124"), 1) + self.assertEqual(outFD1_lines.count("Old string: three l"), 1) + self.assertEqual(outFD1_lines.count("New string: Three l"), 1) + self.assertEqual(outFD1_lines.count("Location start: 206"), 1) + self.assertEqual(outFD1_lines.count("Location end: 213"), 1) + self.assertEqual(outFD1_lines.count("Old string: one m"), 1) + self.assertEqual(outFD1_lines.count("New string: One m"), 1) + self.assertEqual(outFD1_lines.count("Location start: 343"), 1) + self.assertEqual(outFD1_lines.count("Location end: 348"), 1) + self.assertEqual(outFD1_lines.count("Old string: one n"), 1) + self.assertEqual(outFD1_lines.count("New string: One n"), 1) + self.assertEqual(outFD1_lines.count("Location start: 423"), 1) + self.assertEqual(outFD1_lines.count("Location end: 428"), 1) + self.assertEqual(outFD1_lines.count("Old string: contract three"), 1) + self.assertEqual(outFD1_lines.count("New string: contract Three"), 1) + self.assertEqual(outFD1_lines.count("Location start: 498"), 1) + self.assertEqual(outFD1_lines.count("Location end: 512"), 1) + self.assertEqual(outFD1_lines.count("Old string: one"), 1) + self.assertEqual(outFD1_lines.count("New string: One"), 1) + self.assertEqual(outFD1_lines.count("Location start: 646"), 1) + self.assertEqual(outFD1_lines.count("Location end: 649"), 1) + self.assertEqual(outFD1_lines.count("Old string: one r = new one()"), 1) + self.assertEqual(outFD1_lines.count("New string: One r = new one()"), 1) + self.assertEqual(outFD1_lines.count("Location start: 773"), 1) + self.assertEqual(outFD1_lines.count("Location end: 790"), 1) + self.assertEqual(outFD1_lines.count("Old string: one q"), 1) + self.assertEqual(outFD1_lines.count("New string: One q"), 1) + self.assertEqual(outFD1_lines.count("Location start: 871"), 1) + self.assertEqual(outFD1_lines.count("Location end: 876"), 1) + self.assertEqual(outFD1_lines.count("Old string: new one()"), 1) + self.assertEqual(outFD1_lines.count("New string: new One()"), 1) + self.assertEqual(outFD1_lines.count("Location start: 781"), 1) + self.assertEqual(outFD1_lines.count("Location end: 788"), 1) + + def test_naming_convention_modifier(self): + outFD2 = open(self.testFilePath2+".out","r") + outFD2_lines = outFD2.readlines() + outFD2.close() + for i in range(len(outFD2_lines)): + outFD2_lines[i] = outFD2_lines[i].strip() + self.assertTrue(os.path.isfile(self.testFilePath2+".format"),"Patched .format file is not created?!") + self.assertEqual(outFD2_lines[0],"Number of Slither results: 2") + self.assertEqual(outFD2_lines[1],"Number of patches: 4") + self.assertEqual(outFD2_lines.count("Detector: naming-convention (modifier definition)"), 2) + self.assertEqual(outFD2_lines.count("Detector: naming-convention (modifier uses)"), 2) + self.assertEqual(outFD2_lines.count("Old string: modifier One"), 1) + self.assertEqual(outFD2_lines.count("New string: modifier one"), 1) + self.assertEqual(outFD2_lines.count("Location start: 215"), 1) + self.assertEqual(outFD2_lines.count("Location end: 227"), 1) + self.assertEqual(outFD2_lines.count("Old string: () One"), 1) + self.assertEqual(outFD2_lines.count("New string: () one"), 1) + self.assertEqual(outFD2_lines.count("Location start: 288"), 1) + self.assertEqual(outFD2_lines.count("Location end: 295"), 1) + self.assertEqual(outFD2_lines.count("Old string: modifier Two"), 1) + self.assertEqual(outFD2_lines.count("New string: modifier two"), 1) + self.assertEqual(outFD2_lines.count("Location start: 423"), 1) + self.assertEqual(outFD2_lines.count("Location end: 435"), 1) + self.assertEqual(outFD2_lines.count("Old string: () one Two returns"), 1) + self.assertEqual(outFD2_lines.count("New string: () one two returns"), 1) + self.assertEqual(outFD2_lines.count("Location start: 503"), 1) + self.assertEqual(outFD2_lines.count("Location end: 522"), 1) + + def test_naming_convention_structure(self): + outFD3 = open(self.testFilePath3+".out","r") + outFD3_lines = outFD3.readlines() + outFD3.close() + for i in range(len(outFD3_lines)): + outFD3_lines[i] = outFD3_lines[i].strip() + self.assertTrue(os.path.isfile(self.testFilePath3+".format"),"Patched .format file is not created?!") + self.assertEqual(outFD3_lines[0],"Number of Slither results: 2") + self.assertEqual(outFD3_lines[1],"Number of patches: 6") + self.assertEqual(outFD3_lines.count("Detector: naming-convention (struct definition)"), 2) + self.assertEqual(outFD3_lines.count("Detector: naming-convention (struct use)"), 4) + self.assertEqual(outFD3_lines.count("Old string: struct s { uint i; }"), 2) + self.assertEqual(outFD3_lines.count("New string: struct S { uint i; }"), 2) + self.assertEqual(outFD3_lines.count("Location start: 108"), 1) + self.assertEqual(outFD3_lines.count("Location end: 134"), 1) + self.assertEqual(outFD3_lines.count("Location start: 434"), 1) + self.assertEqual(outFD3_lines.count("Location end: 460"), 1) + self.assertEqual(outFD3_lines.count("Old string: s s1"), 2) + self.assertEqual(outFD3_lines.count("New string: S s1"), 2) + self.assertEqual(outFD3_lines.count("Location start: 171"), 1) + self.assertEqual(outFD3_lines.count("Location end: 175"), 1) + self.assertEqual(outFD3_lines.count("Location start: 497"), 1) + self.assertEqual(outFD3_lines.count("Location end: 501"), 1) + self.assertEqual(outFD3_lines.count("Old string: s sA"), 1) + self.assertEqual(outFD3_lines.count("New string: S sA"), 1) + self.assertEqual(outFD3_lines.count("Location start: 570"), 1) + self.assertEqual(outFD3_lines.count("Location end: 574"), 1) + self.assertEqual(outFD3_lines.count("Old string: s"), 1) + self.assertEqual(outFD3_lines.count("New string: S"), 1) + self.assertEqual(outFD3_lines.count("Location start: 585"), 1) + self.assertEqual(outFD3_lines.count("Location end: 586"), 1) + + def test_naming_convention_enum(self): + outFD4 = open(self.testFilePath4+".out","r") + outFD4_lines = outFD4.readlines() + outFD4.close() + for i in range(len(outFD4_lines)): + outFD4_lines[i] = outFD4_lines[i].strip() + self.assertTrue(os.path.isfile(self.testFilePath4+".format"),"Patched .format file is not created?!") + self.assertEqual(outFD4_lines[0],"Number of Slither results: 2") + self.assertEqual(outFD4_lines[1],"Number of patches: 8") + self.assertEqual(outFD4_lines.count("Detector: naming-convention (enum definition)"), 2) + self.assertEqual(outFD4_lines.count("Detector: naming-convention (enum use)"), 6) + self.assertEqual(outFD4_lines.count("Old string: enum e {ONE, TWO}"), 2) + self.assertEqual(outFD4_lines.count("New string: enum E {ONE, TWO}"), 2) + self.assertEqual(outFD4_lines.count("Location start: 73"), 1) + self.assertEqual(outFD4_lines.count("Location end: 90"), 1) + self.assertEqual(outFD4_lines.count("Location start: 426"), 1) + self.assertEqual(outFD4_lines.count("Location end: 443"), 1) + self.assertEqual(outFD4_lines.count("Old string: e e1"), 2) + self.assertEqual(outFD4_lines.count("New string: E e1"), 2) + self.assertEqual(outFD4_lines.count("Location start: 125"), 1) + self.assertEqual(outFD4_lines.count("Location end: 129"), 1) + self.assertEqual(outFD4_lines.count("Location start: 478"), 1) + self.assertEqual(outFD4_lines.count("Location end: 482"), 1) + self.assertEqual(outFD4_lines.count("Old string: e eA"), 1) + self.assertEqual(outFD4_lines.count("New string: E eA"), 1) + self.assertEqual(outFD4_lines.count("Location start: 549"), 1) + self.assertEqual(outFD4_lines.count("Location end: 553"), 1) + self.assertEqual(outFD4_lines.count("Old string: e e2 = eA"), 1) + self.assertEqual(outFD4_lines.count("New string: E e2 = eA"), 1) + self.assertEqual(outFD4_lines.count("Location start: 573"), 1) + self.assertEqual(outFD4_lines.count("Location end: 582"), 1) + self.assertEqual(outFD4_lines.count("Old string: e.ONE"), 1) + self.assertEqual(outFD4_lines.count("New string: E.ONE"), 1) + self.assertEqual(outFD4_lines.count("Location start: 186"), 1) + self.assertEqual(outFD4_lines.count("Location end: 192"), 1) + + def test_naming_convention_event(self): + outFD5 = open(self.testFilePath5+".out","r") + outFD5_lines = outFD5.readlines() + outFD5.close() + for i in range(len(outFD5_lines)): + outFD5_lines[i] = outFD5_lines[i].strip() + self.assertTrue(os.path.isfile(self.testFilePath5+".format"),"Patched .format file is not created?!") + self.assertEqual(outFD5_lines[0],"Number of Slither results: 2") + self.assertEqual(outFD5_lines[1],"Number of patches: 4") + self.assertEqual(outFD5_lines.count("Detector: naming-convention (event definition)"), 2) + self.assertEqual(outFD5_lines.count("Detector: naming-convention (event calls)"), 2) + self.assertEqual(outFD5_lines.count("Old string: event e(uint);"), 2) + self.assertEqual(outFD5_lines.count("New string: event E(uint);"), 2) + self.assertEqual(outFD5_lines.count("Location start: 75"), 1) + self.assertEqual(outFD5_lines.count("Location end: 89"), 1) + self.assertEqual(outFD5_lines.count("Location start: 148"), 1) + self.assertEqual(outFD5_lines.count("Location end: 152"), 1) + self.assertEqual(outFD5_lines.count("Old string: e(i)"), 2) + self.assertEqual(outFD5_lines.count("New string: E(i)"), 2) + self.assertEqual(outFD5_lines.count("Location start: 148"), 1) + self.assertEqual(outFD5_lines.count("Location end: 152"), 1) + self.assertEqual(outFD5_lines.count("Location start: 438"), 1) + self.assertEqual(outFD5_lines.count("Location end: 442"), 1) + + def test_naming_convention_function(self): + outFD6 = open(self.testFilePath6+".out","r") + outFD6_lines = outFD6.readlines() + outFD6.close() + for i in range(len(outFD6_lines)): + outFD6_lines[i] = outFD6_lines[i].strip() + self.assertTrue(os.path.isfile(self.testFilePath6+".format"),"Patched .format file is not created?!") + self.assertEqual(outFD6_lines[0],"Number of Slither results: 2") + self.assertEqual(outFD6_lines[1],"Number of patches: 4") + self.assertEqual(outFD6_lines.count("Detector: naming-convention (function definition)"), 2) + self.assertEqual(outFD6_lines.count("Detector: naming-convention (function calls)"), 2) + self.assertEqual(outFD6_lines.count("Old string: function Foo"), 1) + self.assertEqual(outFD6_lines.count("New string: function foo"), 1) + self.assertEqual(outFD6_lines.count("Location start: 76"), 1) + self.assertEqual(outFD6_lines.count("Location end: 88"), 1) + self.assertEqual(outFD6_lines.count("Old string: function Foobar"), 1) + self.assertEqual(outFD6_lines.count("New string: function foobar"), 1) + self.assertEqual(outFD6_lines.count("Location start: 189"), 1) + self.assertEqual(outFD6_lines.count("Location end: 204"), 1) + self.assertEqual(outFD6_lines.count("Old string: Foobar(10)"), 1) + self.assertEqual(outFD6_lines.count("New string: foobar(10)"), 1) + self.assertEqual(outFD6_lines.count("Location start: 136"), 1) + self.assertEqual(outFD6_lines.count("Location end: 146"), 1) + self.assertEqual(outFD6_lines.count("Old string: a.Foobar(10)"), 1) + self.assertEqual(outFD6_lines.count("New string: a.foobar(10)"), 1) + self.assertEqual(outFD6_lines.count("Location start: 516"), 1) + self.assertEqual(outFD6_lines.count("Location end: 528"), 1) + + def test_naming_convention_parameter(self): + outFD7 = open(self.testFilePath7+".out","r") + outFD7_lines = outFD7.readlines() + outFD7.close() + for i in range(len(outFD7_lines)): + outFD7_lines[i] = outFD7_lines[i].strip() + self.assertTrue(os.path.isfile(self.testFilePath7+".format"),"Patched .format file is not created?!") + self.assertEqual(outFD7_lines[0],"Number of Slither results: 6") + self.assertEqual(outFD7_lines[1],"Number of patches: 12") + self.assertEqual(outFD7_lines.count("Detector: naming-convention (parameter declaration)"), 6) + self.assertEqual(outFD7_lines.count("Detector: naming-convention (parameter uses)"), 6) + self.assertEqual(outFD7_lines.count("Old string: uint Count"), 3) + self.assertEqual(outFD7_lines.count("New string: uint _Count"), 3) + self.assertEqual(outFD7_lines.count("Location start: 91"), 1) + self.assertEqual(outFD7_lines.count("Location end: 101"), 1) + self.assertEqual(outFD7_lines.count("Location start: 215"), 1) + self.assertEqual(outFD7_lines.count("Location end: 225"), 1) + self.assertEqual(outFD7_lines.count("Old string: Count"), 3) + self.assertEqual(outFD7_lines.count("New string: _Count"), 3) + self.assertEqual(outFD7_lines.count("Location start: 148"), 1) + self.assertEqual(outFD7_lines.count("Location end: 153"), 1) + self.assertEqual(outFD7_lines.count("Location start: 308"), 1) + self.assertEqual(outFD7_lines.count("Location end: 313"), 1) + self.assertEqual(outFD7_lines.count("Location start: 489"), 1) + self.assertEqual(outFD7_lines.count("Location end: 499"), 1) + self.assertEqual(outFD7_lines.count("Location start: 580"), 1) + self.assertEqual(outFD7_lines.count("Location end: 585"), 1) + self.assertEqual(outFD7_lines.count("Old string: Count)"), 1) + self.assertEqual(outFD7_lines.count("New string: _Count)"), 1) + self.assertEqual(outFD7_lines.count("Location start: 506"), 1) + self.assertEqual(outFD7_lines.count("Location end: 512"), 1) + self.assertEqual(outFD7_lines.count("Old string: uint Number"), 1) + self.assertEqual(outFD7_lines.count("New string: uint _Number"), 1) + self.assertEqual(outFD7_lines.count("Location start: 227"), 1) + self.assertEqual(outFD7_lines.count("Location end: 238"), 1) + self.assertEqual(outFD7_lines.count("Old string: Number"), 1) + self.assertEqual(outFD7_lines.count("New string: _Number"), 1) + self.assertEqual(outFD7_lines.count("Location start: 314"), 1) + self.assertEqual(outFD7_lines.count("Location end: 320"), 1) + self.assertEqual(outFD7_lines.count("Old string: address _to"), 1) + self.assertEqual(outFD7_lines.count("New string: address _To"), 1) + self.assertEqual(outFD7_lines.count("Location start: 708"), 1) + self.assertEqual(outFD7_lines.count("Location end: 719"), 1) + self.assertEqual(outFD7_lines.count("Old string: address _from"), 1) + self.assertEqual(outFD7_lines.count("New string: address _From"), 1) + self.assertEqual(outFD7_lines.count("Location start: 721"), 1) + self.assertEqual(outFD7_lines.count("Location end: 734"), 1) + self.assertEqual(outFD7_lines.count("Old string: _to"), 1) + self.assertEqual(outFD7_lines.count("New string: _To"), 1) + self.assertEqual(outFD7_lines.count("Location start: 811"), 1) + self.assertEqual(outFD7_lines.count("Location end: 814"), 1) + self.assertEqual(outFD7_lines.count("Old string: _from"), 1, "Index variables of writes are not captured by node._expression_vars_read of Slither") + self.assertEqual(outFD7_lines.count("New string: _From"), 1) + + def test_naming_convention_state_variable(self): + outFD8 = open(self.testFilePath8+".out","r") + outFD8_lines = outFD8.readlines() + outFD8.close() + for i in range(len(outFD8_lines)): + outFD8_lines[i] = outFD8_lines[i].strip() + self.assertTrue(os.path.isfile(self.testFilePath8+".format"),"Patched .format file is not created?!") + self.assertEqual(outFD8_lines[0],"Number of Slither results: 3") + self.assertEqual(outFD8_lines[1],"Number of patches: 7") + self.assertEqual(outFD8_lines.count("Detector: naming-convention (state variable declaration)"), 3) + self.assertEqual(outFD8_lines.count("Detector: naming-convention (state variable uses)"), 4) + self.assertEqual(outFD8_lines.count("Old string: number"), 2) + self.assertEqual(outFD8_lines.count("New string: NUMBER"), 2) + self.assertEqual(outFD8_lines.count("Location start: 469"), 1) + self.assertEqual(outFD8_lines.count("Location end: 475"), 1) + self.assertEqual(outFD8_lines.count("Location start: 716"), 1) + self.assertEqual(outFD8_lines.count("Location end: 722"), 1) + self.assertEqual(outFD8_lines.count("Old string: Count"), 3) + self.assertEqual(outFD8_lines.count("New string: count"), 3) + self.assertEqual(outFD8_lines.count("Location start: 547"), 1) + self.assertEqual(outFD8_lines.count("Location end: 552"), 1) + self.assertEqual(outFD8_lines.count("Location start: 725"), 1) + self.assertEqual(outFD8_lines.count("Location end: 730"), 1) + self.assertEqual(outFD8_lines.count("Location start: 745"), 1) + self.assertEqual(outFD8_lines.count("Location end: 750"), 1) + self.assertEqual(outFD8_lines.count("Old string: Maxnum"), 2) + self.assertEqual(outFD8_lines.count("New string: maxnum"), 2) + self.assertEqual(outFD8_lines.count("Location start: 634"), 1) + self.assertEqual(outFD8_lines.count("Location end: 640"), 1) + self.assertEqual(outFD8_lines.count("Location start: 733"), 1) + self.assertEqual(outFD8_lines.count("Location end: 739"), 1) + +if __name__ == '__main__': + unittest.main() diff --git a/utils/slither_format/tests/test_pragma.py b/utils/slither_format/tests/test_pragma.py new file mode 100644 index 000000000..38818124e --- /dev/null +++ b/utils/slither_format/tests/test_pragma.py @@ -0,0 +1,75 @@ +import unittest +import subprocess, os, sys + +class TestPragma(unittest.TestCase): + testDataDir = "./slither_format/tests/test_data/" + testDataFile1 = "pragma.0.4.24.sol" + testImportFile1 = "pragma.0.4.23.sol" + testFilePath1 = testDataDir+testDataFile1 + testImportFilePath1 = testDataDir+testImportFile1 + testDataFile2 = "pragma.0.5.4.sol" + testImportFile2 = "pragma.0.5.2.sol" + testFilePath2 = testDataDir+testDataFile2 + testImportFilePath2 = testDataDir+testImportFile2 + + def setUp(self): + outFD1 = open(self.testFilePath1+".out","w") + errFD1 = open(self.testFilePath1+".err","w") + p1 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose','--detect','pragma',self.testFilePath1], stdout=outFD1,stderr=errFD1) + p1.wait() + outFD1.close() + errFD1.close() + + outFD2 = open(self.testFilePath2+".out","w") + errFD2 = open(self.testFilePath2+".err","w") + my_env = os.environ.copy() + my_env["SOLC_VERSION"] = "0.5.4" + p2 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose','--detect','pragma',self.testFilePath2], stdout=outFD2,stderr=errFD2, env=my_env) + p2.wait() + outFD2.close() + errFD2.close() + + def tearDown(self): + p1 = subprocess.Popen(['rm','-f',self.testFilePath1+'.out',self.testFilePath1+'.err',self.testFilePath1+'.format',self.testImportFilePath1+'.format']) + p1.wait() + + p2 = subprocess.Popen(['rm','-f',self.testFilePath2+'.out',self.testFilePath2+'.err',self.testFilePath2+'.format',self.testImportFilePath2+'.format']) + p2.wait() + + def test_pragma(self): + outFD1 = open(self.testFilePath1+".out","r") + outFD1_lines = outFD1.readlines() + for i in range(len(outFD1_lines)): + outFD1_lines[i] = outFD1_lines[i].strip() + self.assertTrue(os.path.isfile(self.testFilePath1+".format"),"Patched .format file is not created?!") + self.assertEqual(outFD1_lines[0],"Number of Slither results: 2") + self.assertEqual(outFD1_lines[1],"Number of patches: 2") + self.assertEqual(outFD1_lines.count("Detector: pragma"), 2) + self.assertEqual(outFD1_lines.count("Old string: pragma solidity ^0.4.23;"), 1) + self.assertEqual(outFD1_lines.count("Old string: pragma solidity ^0.4.24;"), 1) + self.assertEqual(outFD1_lines.count("New string: pragma solidity 0.4.25;"), 2) + self.assertEqual(outFD1_lines.count("Location start: 0"), 2) + self.assertEqual(outFD1_lines.count("Location end: 24"), 2) + self.assertEqual(outFD1_lines.count("Patch file: ./slither_format/tests/test_data/pragma.0.4.24.sol"), 1) + self.assertEqual(outFD1_lines.count("Patch file: ./slither_format/tests/test_data/pragma.0.4.23.sol"), 1) + outFD1.close() + + outFD2 = open(self.testFilePath2+".out","r") + outFD2_lines = outFD2.readlines() + for i in range(len(outFD2_lines)): + outFD2_lines[i] = outFD2_lines[i].strip() + self.assertTrue(os.path.isfile(self.testFilePath2+".format"),"Patched .format file is not created?!") + self.assertEqual(outFD2_lines[0],"Number of Slither results: 2") + self.assertEqual(outFD2_lines[1],"Number of patches: 2") + self.assertEqual(outFD2_lines.count("Detector: pragma"), 2) + self.assertEqual(outFD2_lines.count("Old string: pragma solidity ^0.5.4;"), 1) + self.assertEqual(outFD2_lines.count("Old string: pragma solidity ^0.5.2;"), 1) + self.assertEqual(outFD2_lines.count("New string: pragma solidity 0.5.3;"), 2) + self.assertEqual(outFD2_lines.count("Location start: 0"), 2) + self.assertEqual(outFD2_lines.count("Location end: 23"), 2) + self.assertEqual(outFD2_lines.count("Patch file: ./slither_format/tests/test_data/pragma.0.5.4.sol"), 1) + self.assertEqual(outFD2_lines.count("Patch file: ./slither_format/tests/test_data/pragma.0.5.2.sol"), 1) + outFD2.close() + +if __name__ == '__main__': + unittest.main() diff --git a/utils/slither_format/tests/test_solc_version.py b/utils/slither_format/tests/test_solc_version.py new file mode 100644 index 000000000..9f9a55dd2 --- /dev/null +++ b/utils/slither_format/tests/test_solc_version.py @@ -0,0 +1,118 @@ +import unittest +import subprocess, os, sys + +class TestSolcVersion(unittest.TestCase): + testDataDir = "./slither_format/tests/test_data/" + testDataFile1 = "solc_version_incorrect1.sol" + testFilePath1 = testDataDir+testDataFile1 + testDataFile2 = "solc_version_incorrect2.sol" + testFilePath2 = testDataDir+testDataFile2 + testDataFile3 = "solc_version_incorrect3.sol" + testFilePath3 = testDataDir+testDataFile3 + testDataFile4 = "solc_version_incorrect4.sol" + testFilePath4 = testDataDir+testDataFile4 + + def setUp(self): + outFD1 = open(self.testFilePath1+".out","w") + errFD1 = open(self.testFilePath1+".err","w") + p1 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose','--detect','solc-version',self.testFilePath1], stdout=outFD1,stderr=errFD1) + p1.wait() + outFD1.close() + errFD1.close() + + outFD2 = open(self.testFilePath2+".out","w") + errFD2 = open(self.testFilePath2+".err","w") + p2 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose','--detect','solc-version',self.testFilePath2], stdout=outFD2,stderr=errFD2) + p2.wait() + outFD2.close() + errFD2.close() + + outFD3 = open(self.testFilePath3+".out","w") + errFD3 = open(self.testFilePath3+".err","w") + p3 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose','--detect','solc-version',self.testFilePath3], stdout=outFD3,stderr=errFD3) + p3.wait() + outFD3.close() + errFD3.close() + + outFD4 = open(self.testFilePath4+".out","w") + errFD4 = open(self.testFilePath4+".err","w") + my_env = os.environ.copy() + my_env["SOLC_VERSION"] = "0.5.2" + p4 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose','--detect','solc-version',self.testFilePath4], stdout=outFD4,stderr=errFD4, env=my_env) + p4.wait() + outFD4.close() + errFD4.close() + + def tearDown(self): + p1 = subprocess.Popen(['rm','-f',self.testFilePath1+'.out',self.testFilePath1+'.err',self.testFilePath1+'.format']) + p1.wait() + p2 = subprocess.Popen(['rm','-f',self.testFilePath2+'.out',self.testFilePath2+'.err',self.testFilePath2+'.format']) + p2.wait() + p3 = subprocess.Popen(['rm','-f',self.testFilePath3+'.out',self.testFilePath3+'.err',self.testFilePath3+'.format']) + p3.wait() + p4 = subprocess.Popen(['rm','-f',self.testFilePath4+'.out',self.testFilePath4+'.err',self.testFilePath4+'.format']) + p4.wait() + + def test_solc_version(self): + outFD1 = open(self.testFilePath1+".out","r") + outFD1_lines = outFD1.readlines() + for i in range(len(outFD1_lines)): + outFD1_lines[i] = outFD1_lines[i].strip() + self.assertTrue(os.path.isfile(self.testFilePath1+".format"),"Patched .format file is not created?!") + self.assertEqual(outFD1_lines[0],"Number of Slither results: 1") + self.assertEqual(outFD1_lines[1],"Number of patches: 1") + self.assertEqual(outFD1_lines.count("Detector: solc-version"), 1) + self.assertEqual(outFD1_lines.count("Old string: pragma solidity ^0.4.23;"), 1) + self.assertEqual(outFD1_lines.count("New string: pragma solidity 0.4.25;"), 1) + self.assertEqual(outFD1_lines.count("Location start: 63"), 1) + self.assertEqual(outFD1_lines.count("Location end: 87"), 1) + self.assertEqual(outFD1_lines.count("Patch file: ./slither_format/tests/test_data/solc_version_incorrect1.sol"), 1) + outFD1.close() + + outFD2 = open(self.testFilePath2+".out","r") + outFD2_lines = outFD2.readlines() + for i in range(len(outFD2_lines)): + outFD2_lines[i] = outFD2_lines[i].strip() + self.assertTrue(os.path.isfile(self.testFilePath2+".format"),"Patched .format file is not created?!") + self.assertEqual(outFD2_lines[0],"Number of Slither results: 1") + self.assertEqual(outFD2_lines[1],"Number of patches: 1") + self.assertEqual(outFD2_lines.count("Detector: solc-version"), 1) + self.assertEqual(outFD2_lines.count("Old string: pragma solidity >=0.4.0 <0.6.0;"), 1) + self.assertEqual(outFD2_lines.count("New string: pragma solidity 0.5.3;"), 1) + self.assertEqual(outFD2_lines.count("Location start: 63"), 1) + self.assertEqual(outFD2_lines.count("Location end: 94"), 1) + self.assertEqual(outFD2_lines.count("Patch file: ./slither_format/tests/test_data/solc_version_incorrect2.sol"), 1) + outFD2.close() + + outFD3 = open(self.testFilePath3+".out","r") + outFD3_lines = outFD3.readlines() + for i in range(len(outFD3_lines)): + outFD3_lines[i] = outFD3_lines[i].strip() + self.assertTrue(os.path.isfile(self.testFilePath3+".format"),"Patched .format file is not created?!") + self.assertEqual(outFD3_lines[0],"Number of Slither results: 1") + self.assertEqual(outFD3_lines[1],"Number of patches: 1") + self.assertEqual(outFD3_lines.count("Detector: solc-version"), 1) + self.assertEqual(outFD3_lines.count("Old string: pragma solidity >=0.4.0 <0.4.25;"), 1) + self.assertEqual(outFD3_lines.count("New string: pragma solidity 0.4.25;"), 1) + self.assertEqual(outFD3_lines.count("Location start: 63"), 1) + self.assertEqual(outFD3_lines.count("Location end: 95"), 1) + self.assertEqual(outFD3_lines.count("Patch file: ./slither_format/tests/test_data/solc_version_incorrect3.sol"), 1) + outFD3.close() + + outFD4 = open(self.testFilePath4+".out","r") + outFD4_lines = outFD4.readlines() + for i in range(len(outFD4_lines)): + outFD4_lines[i] = outFD4_lines[i].strip() + self.assertTrue(os.path.isfile(self.testFilePath4+".format"),"Patched .format file is not created?!") + self.assertEqual(outFD4_lines[0],"Number of Slither results: 1") + self.assertEqual(outFD4_lines[1],"Number of patches: 1") + self.assertEqual(outFD4_lines.count("Detector: solc-version"), 1) + self.assertEqual(outFD4_lines.count("Old string: pragma solidity ^0.5.1;"), 1) + self.assertEqual(outFD4_lines.count("New string: pragma solidity 0.5.3;"), 1) + self.assertEqual(outFD4_lines.count("Location start: 63"), 1) + self.assertEqual(outFD4_lines.count("Location end: 86"), 1) + self.assertEqual(outFD4_lines.count("Patch file: ./slither_format/tests/test_data/solc_version_incorrect4.sol"), 1) + outFD4.close() + +if __name__ == '__main__': + unittest.main() diff --git a/utils/slither_format/tests/test_unused_state_vars.py b/utils/slither_format/tests/test_unused_state_vars.py new file mode 100644 index 000000000..ee329aa38 --- /dev/null +++ b/utils/slither_format/tests/test_unused_state_vars.py @@ -0,0 +1,37 @@ +import unittest +import subprocess, os, sys + +class TestUnusedStateVars(unittest.TestCase): + testDataFile = "unused_state.sol" + testDataDir = "./slither_format/tests/test_data/" + testFilePath = testDataDir+testDataFile + + def setUp(self): + outFD = open(self.testFilePath+".out","w") + errFD = open(self.testFilePath+".err","w") + p = subprocess.Popen(['python3', '-m', 'slither_format','--verbose','--detect','unused-state',self.testFilePath], stdout=outFD,stderr=errFD) + p.wait() + outFD.close() + errFD.close() + + def tearDown(self): + p = subprocess.Popen(['rm','-f',self.testFilePath+'.out',self.testFilePath+'.err',self.testFilePath+'.format']) + p.wait() + + def test_unused_state_vars(self): + outFD = open(self.testFilePath+".out","r") + outFD_lines = outFD.readlines() + for i in range(len(outFD_lines)): + outFD_lines[i] = outFD_lines[i].strip() + self.assertTrue(os.path.isfile(self.testFilePath+".format"),"Patched .format file is not created?!") + self.assertEqual(outFD_lines[0].rstrip(),"Number of Slither results: 1") + self.assertEqual(outFD_lines[1].rstrip(),"Number of patches: 1") + self.assertEqual(outFD_lines.count("Detector: unused-state"), 1) + self.assertEqual(outFD_lines.count("Old string: address unused ;"), 1) + self.assertEqual(outFD_lines.count("New string:"), 1) + self.assertEqual(outFD_lines.count("Location start: 44"), 1) + self.assertEqual(outFD_lines.count("Location end: 63"), 1) + outFD.close() + +if __name__ == '__main__': + unittest.main() From c25649eda03ff917717dbeb8a27636b9e2b3f38a Mon Sep 17 00:00:00 2001 From: rajeevgopalakrishna Date: Mon, 13 May 2019 12:12:42 +0530 Subject: [PATCH 002/223] Updates format_constant_function to use filename_absolute. test_constant_function passes. --- utils/slither_format/format_constant_function.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/utils/slither_format/format_constant_function.py b/utils/slither_format/format_constant_function.py index 15154463a..13bc725a0 100644 --- a/utils/slither_format/format_constant_function.py +++ b/utils/slither_format/format_constant_function.py @@ -13,7 +13,7 @@ class FormatConstantFunction: if not Found: for function in contract.functions: if contract.name == element['contract']['name'] and function.name == element['name']: - FormatConstantFunction.create_patch(slither, patches, element['source_mapping']['filename'], ["view","pure","constant"], "", int(function.parameters_src.split(':')[0]), int(function.returns_src.split(':')[0])) + FormatConstantFunction.create_patch(slither, patches, element['source_mapping']['filename_absolute'], ["view","pure","constant"], "", int(function.parameters_src.split(':')[0]), int(function.returns_src.split(':')[0])) Found = True @staticmethod From d27197396536d8af23db6b987530ed53eb9c6e15 Mon Sep 17 00:00:00 2001 From: rajeevgopalakrishna Date: Mon, 13 May 2019 13:06:32 +0530 Subject: [PATCH 003/223] Updates format_unused_state to use filename_absolute and apply only to variable types. test_unused_state_vars passes. --- utils/slither_format/format_unused_state.py | 3 ++- utils/slither_format/slither_format.py | 2 ++ 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/utils/slither_format/format_unused_state.py b/utils/slither_format/format_unused_state.py index 20b0e08b8..ec2ea63da 100644 --- a/utils/slither_format/format_unused_state.py +++ b/utils/slither_format/format_unused_state.py @@ -3,7 +3,8 @@ class FormatUnusedState: @staticmethod def format(slither, patches, elements): for element in elements: - FormatUnusedState.create_patch(slither, patches, element['source_mapping']['filename'], element['source_mapping']['start']) + if element['type'] == "variable": + FormatUnusedState.create_patch(slither, patches, element['source_mapping']['filename_absolute'], element['source_mapping']['start']) @staticmethod def create_patch(slither, patches, in_file, modify_loc_start): diff --git a/utils/slither_format/slither_format.py b/utils/slither_format/slither_format.py index 1c1831b59..e29713acf 100644 --- a/utils/slither_format/slither_format.py +++ b/utils/slither_format/slither_format.py @@ -127,6 +127,8 @@ def get_number_of_slither_results (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 From f0e8077ad114ddd49a2874ea1b4752f04b43bd96 Mon Sep 17 00:00:00 2001 From: rajeevgopalakrishna Date: Mon, 13 May 2019 14:32:20 +0530 Subject: [PATCH 004/223] Updates format_constable_states to use filename_absolute. test_constable_states passes. --- utils/slither_format/format_constable_states.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/utils/slither_format/format_constable_states.py b/utils/slither_format/format_constable_states.py index 63b1bc4ed..fd3f8245f 100644 --- a/utils/slither_format/format_constable_states.py +++ b/utils/slither_format/format_constable_states.py @@ -5,7 +5,7 @@ class FormatConstableStates: @staticmethod def format(slither, patches, elements): for element in elements: - FormatConstableStates.create_patch(slither, patches, element['source_mapping']['filename'], element['name'], "constant " + element['name'], element['source_mapping']['start'], element['source_mapping']['start'] + element['source_mapping']['length']) + FormatConstableStates.create_patch(slither, patches, element['source_mapping']['filename_absolute'], element['name'], "constant " + element['name'], element['source_mapping']['start'], element['source_mapping']['start'] + element['source_mapping']['length']) @staticmethod def create_patch(slither, patches, in_file, match_text, replace_text, modify_loc_start, modify_loc_end): From 8a4f8235bb9aa0099529c1ce5e7e13bca834299f Mon Sep 17 00:00:00 2001 From: rajeevgopalakrishna Date: Mon, 13 May 2019 14:50:12 +0530 Subject: [PATCH 005/223] Updates format_solc_version to use filename_absolute and, directive name instead of the earlier expression name. test_solc_version passes. Removes patch_file check for now. Need to change verbose output to JSON format and include patch_file then. --- utils/slither_format/format_solc_version.py | 4 ++-- utils/slither_format/tests/test_solc_version.py | 4 ---- 2 files changed, 2 insertions(+), 6 deletions(-) diff --git a/utils/slither_format/format_solc_version.py b/utils/slither_format/format_solc_version.py index 687d62b7c..2cc13fc84 100644 --- a/utils/slither_format/format_solc_version.py +++ b/utils/slither_format/format_solc_version.py @@ -16,8 +16,8 @@ class FormatSolcVersion: @staticmethod def format(slither, patches, elements): for element in elements: - solc_version_replace = FormatSolcVersion.determine_solc_version_replacement(element['expression']) - FormatSolcVersion.create_patch(slither, patches, element['source_mapping']['filename'], solc_version_replace, element['source_mapping']['start'], element['source_mapping']['start'] + element['source_mapping']['length']) + solc_version_replace = FormatSolcVersion.determine_solc_version_replacement(''.join(element['directive'][1:])) + FormatSolcVersion.create_patch(slither, patches, element['source_mapping']['filename_absolute'], solc_version_replace, element['source_mapping']['start'], element['source_mapping']['start'] + element['source_mapping']['length']) @staticmethod def determine_solc_version_replacement(used_solc_version): diff --git a/utils/slither_format/tests/test_solc_version.py b/utils/slither_format/tests/test_solc_version.py index 9f9a55dd2..c2d6eb2cc 100644 --- a/utils/slither_format/tests/test_solc_version.py +++ b/utils/slither_format/tests/test_solc_version.py @@ -66,7 +66,6 @@ class TestSolcVersion(unittest.TestCase): self.assertEqual(outFD1_lines.count("New string: pragma solidity 0.4.25;"), 1) self.assertEqual(outFD1_lines.count("Location start: 63"), 1) self.assertEqual(outFD1_lines.count("Location end: 87"), 1) - self.assertEqual(outFD1_lines.count("Patch file: ./slither_format/tests/test_data/solc_version_incorrect1.sol"), 1) outFD1.close() outFD2 = open(self.testFilePath2+".out","r") @@ -81,7 +80,6 @@ class TestSolcVersion(unittest.TestCase): self.assertEqual(outFD2_lines.count("New string: pragma solidity 0.5.3;"), 1) self.assertEqual(outFD2_lines.count("Location start: 63"), 1) self.assertEqual(outFD2_lines.count("Location end: 94"), 1) - self.assertEqual(outFD2_lines.count("Patch file: ./slither_format/tests/test_data/solc_version_incorrect2.sol"), 1) outFD2.close() outFD3 = open(self.testFilePath3+".out","r") @@ -96,7 +94,6 @@ class TestSolcVersion(unittest.TestCase): self.assertEqual(outFD3_lines.count("New string: pragma solidity 0.4.25;"), 1) self.assertEqual(outFD3_lines.count("Location start: 63"), 1) self.assertEqual(outFD3_lines.count("Location end: 95"), 1) - self.assertEqual(outFD3_lines.count("Patch file: ./slither_format/tests/test_data/solc_version_incorrect3.sol"), 1) outFD3.close() outFD4 = open(self.testFilePath4+".out","r") @@ -111,7 +108,6 @@ class TestSolcVersion(unittest.TestCase): self.assertEqual(outFD4_lines.count("New string: pragma solidity 0.5.3;"), 1) self.assertEqual(outFD4_lines.count("Location start: 63"), 1) self.assertEqual(outFD4_lines.count("Location end: 86"), 1) - self.assertEqual(outFD4_lines.count("Patch file: ./slither_format/tests/test_data/solc_version_incorrect4.sol"), 1) outFD4.close() if __name__ == '__main__': From 82495e608a404de6917cf89e95da8c7f483205c7 Mon Sep 17 00:00:00 2001 From: rajeevgopalakrishna Date: Mon, 13 May 2019 15:14:43 +0530 Subject: [PATCH 006/223] Updates format_pragma to use filename_absolute and, directive name instead of the earlier expression name. test_pragma passes. Removes patch_file check for now. Need to change verbose output to JSON format and include patch_file then. --- utils/slither_format/format_pragma.py | 4 ++-- utils/slither_format/tests/test_pragma.py | 4 ---- 2 files changed, 2 insertions(+), 6 deletions(-) diff --git a/utils/slither_format/format_pragma.py b/utils/slither_format/format_pragma.py index f3f06a667..193b64fe6 100644 --- a/utils/slither_format/format_pragma.py +++ b/utils/slither_format/format_pragma.py @@ -17,10 +17,10 @@ class FormatPragma: def format(slither, patches, elements): versions_used = [] for element in elements: - versions_used.append(element['expression']) + versions_used.append(''.join(element['directive'][1:])) solc_version_replace = FormatPragma.analyse_versions(versions_used) for element in elements: - FormatPragma.create_patch(slither, patches, element['source_mapping']['filename'], solc_version_replace, element['source_mapping']['start'], element['source_mapping']['start'] + element['source_mapping']['length']) + FormatPragma.create_patch(slither, patches, element['source_mapping']['filename_absolute'], solc_version_replace, element['source_mapping']['start'], element['source_mapping']['start'] + element['source_mapping']['length']) @staticmethod def analyse_versions(used_solc_versions): diff --git a/utils/slither_format/tests/test_pragma.py b/utils/slither_format/tests/test_pragma.py index 38818124e..1d1e7c1c3 100644 --- a/utils/slither_format/tests/test_pragma.py +++ b/utils/slither_format/tests/test_pragma.py @@ -50,8 +50,6 @@ class TestPragma(unittest.TestCase): self.assertEqual(outFD1_lines.count("New string: pragma solidity 0.4.25;"), 2) self.assertEqual(outFD1_lines.count("Location start: 0"), 2) self.assertEqual(outFD1_lines.count("Location end: 24"), 2) - self.assertEqual(outFD1_lines.count("Patch file: ./slither_format/tests/test_data/pragma.0.4.24.sol"), 1) - self.assertEqual(outFD1_lines.count("Patch file: ./slither_format/tests/test_data/pragma.0.4.23.sol"), 1) outFD1.close() outFD2 = open(self.testFilePath2+".out","r") @@ -67,8 +65,6 @@ class TestPragma(unittest.TestCase): self.assertEqual(outFD2_lines.count("New string: pragma solidity 0.5.3;"), 2) self.assertEqual(outFD2_lines.count("Location start: 0"), 2) self.assertEqual(outFD2_lines.count("Location end: 23"), 2) - self.assertEqual(outFD2_lines.count("Patch file: ./slither_format/tests/test_data/pragma.0.5.4.sol"), 1) - self.assertEqual(outFD2_lines.count("Patch file: ./slither_format/tests/test_data/pragma.0.5.2.sol"), 1) outFD2.close() if __name__ == '__main__': From ced9498f5627fb216f22fee60c40332351d030bc Mon Sep 17 00:00:00 2001 From: rajeevgopalakrishna Date: Mon, 13 May 2019 15:25:42 +0530 Subject: [PATCH 007/223] Updates format_external_function to use filename_absolute. test_external_function passes. --- utils/slither_format/format_external_function.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/utils/slither_format/format_external_function.py b/utils/slither_format/format_external_function.py index 57793aa7d..389b0d06b 100644 --- a/utils/slither_format/format_external_function.py +++ b/utils/slither_format/format_external_function.py @@ -14,7 +14,7 @@ class FormatExternalFunction: # to external because external function parameters are allocated in calldata region which is # non-modifiable. See https://solidity.readthedocs.io/en/develop/types.html#data-location if not FormatExternalFunction.function_parameters_written(function): - FormatExternalFunction.create_patch(slither, patches, element['source_mapping']['filename'], "public", "external", int(function.parameters_src.split(':')[0]), int(function.returns_src.split(':')[0])) + FormatExternalFunction.create_patch(slither, patches, element['source_mapping']['filename_absolute'], "public", "external", int(function.parameters_src.split(':')[0]), int(function.returns_src.split(':')[0])) Found = True break From 4d687c504dc977b3b4f7c22cde197d6470d0e15e Mon Sep 17 00:00:00 2001 From: rajeevgopalakrishna Date: Mon, 13 May 2019 18:15:25 +0530 Subject: [PATCH 008/223] Updates format_naming_convention to use filename_absolute and other JSON output field updates. Removed the use of event.full_name to simply use name instead (so PR #236 not required). naming-convention tests pass (except the index variable test which is expected to fail); run_all_tests passes except that one. Testing requires checking out slither core/parsing changes from dev-slither-changes-for-slither-format-new. --- utils/slither_format/format_naming_convention.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/utils/slither_format/format_naming_convention.py b/utils/slither_format/format_naming_convention.py index 5a60a2a46..a0821478d 100644 --- a/utils/slither_format/format_naming_convention.py +++ b/utils/slither_format/format_naming_convention.py @@ -9,12 +9,12 @@ class FormatNamingConvention: @staticmethod def format(slither, patches, elements): for element in elements: - if (element['target'] == "parameter"): - FormatNamingConvention.create_patch(slither, patches, element['target'], element['name'], element['function'], element['contract'], element['source_mapping']['filename'],element['source_mapping']['start'],(element['source_mapping']['start']+element['source_mapping']['length'])) - elif (element['target'] == "modifier" or element['target'] == "function" or element['target'] == "event" or element['target'] == "variable" or element['target'] == "variable_constant" or element['target'] == "enum" or element['target'] == "structure"): - FormatNamingConvention.create_patch(slither, patches, element['target'], element['name'], element['name'], element['contract'], element['source_mapping']['filename'],element['source_mapping']['start'],(element['source_mapping']['start']+element['source_mapping']['length'])) + if (element['additional_fields']['target'] == "parameter"): + FormatNamingConvention.create_patch(slither, patches, element['additional_fields']['target'], element['name'], element['function']['name'], element['function']['contract']['name'], element['source_mapping']['filename_absolute'],element['source_mapping']['start'],(element['source_mapping']['start']+element['source_mapping']['length'])) + elif (element['additional_fields']['target'] == "modifier" or element['additional_fields']['target'] == "function" or element['additional_fields']['target'] == "event" or element['additional_fields']['target'] == "variable" or element['additional_fields']['target'] == "variable_constant" or element['additional_fields']['target'] == "enum" or element['additional_fields']['target'] == "structure"): + FormatNamingConvention.create_patch(slither, patches, element['additional_fields']['target'], element['name'], element['name'], element['contract']['name'], element['source_mapping']['filename_absolute'],element['source_mapping']['start'],(element['source_mapping']['start']+element['source_mapping']['length'])) else: - FormatNamingConvention.create_patch(slither, patches, element['target'], element['name'], element['name'], element['name'], element['source_mapping']['filename'],element['source_mapping']['start'],(element['source_mapping']['start']+element['source_mapping']['length'])) + FormatNamingConvention.create_patch(slither, patches, element['additional_fields']['target'], element['name'], element['name'], element['name'], element['source_mapping']['filename_absolute'],element['source_mapping']['start'],(element['source_mapping']['start']+element['source_mapping']['length'])) @staticmethod def create_patch(slither, patches, _target, name, function_name, contract_name, in_file, modify_loc_start, modify_loc_end): @@ -252,7 +252,7 @@ class FormatNamingConvention: for contract in slither.contracts: if contract.name == contract_name: for event in contract.events: - if event.full_name == name: + if event.name == name: event_name = name.split('(')[0] in_file_str = slither.source_code[in_file] old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] From f0fa6c6d2cfc6b510e4c55cb1da4038e5de4ff82 Mon Sep 17 00:00:00 2001 From: rajeevgopalakrishna Date: Tue, 14 May 2019 10:08:57 +0530 Subject: [PATCH 009/223] Use source_mapping of variables/events directly instead of get_source_event/var_declaration, which will be removed from slither. --- .../format_naming_convention.py | 36 +++++++++---------- 1 file changed, 18 insertions(+), 18 deletions(-) diff --git a/utils/slither_format/format_naming_convention.py b/utils/slither_format/format_naming_convention.py index a0821478d..72b975497 100644 --- a/utils/slither_format/format_naming_convention.py +++ b/utils/slither_format/format_naming_convention.py @@ -80,12 +80,12 @@ class FormatNamingConvention: svs = contract.variables for sv in svs: if (str(sv.type) == name): - old_str_of_interest = in_file_str[contract.get_source_var_declaration(sv.name)['start']:(contract.get_source_var_declaration(sv.name)['start']+contract.get_source_var_declaration(sv.name)['length'])] + old_str_of_interest = in_file_str[sv.source_mapping['start']:(sv.source_mapping['start']+sv.source_mapping['length'])] (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(),old_str_of_interest, 1) patch = { "detector" : "naming-convention (contract state variable)", - "start" : contract.get_source_var_declaration(sv.name)['start'], - "end" : contract.get_source_var_declaration(sv.name)['start'] + contract.get_source_var_declaration(sv.name)['length'], + "start" : sv.source_mapping['start'], + "end" : sv.source_mapping['start'] + sv.source_mapping['length'], "old_string" : old_str_of_interest, "new_string" : new_str_of_interest } @@ -97,12 +97,12 @@ class FormatNamingConvention: for fm in fms: for v in fm.variables: if (str(v.type) == name): - old_str_of_interest = in_file_str[fm.get_source_var_declaration(v.name)['start']:(fm.get_source_var_declaration(v.name)['start']+fm.get_source_var_declaration(v.name)['length'])] + old_str_of_interest = in_file_str[v.source_mapping['start']:(v.source_mapping['start']+v.source_mapping['length'])] (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(),old_str_of_interest, 1) patch = { "detector" : "naming-convention (contract function variable)", - "start" : fm.get_source_var_declaration(v.name)['start'], - "end" : fm.get_source_var_declaration(v.name)['start'] + fm.get_source_var_declaration(v.name)['length'], + "start" : v.source_mapping['start'], + "end" : v.source_mapping['start'] + v.source_mapping['length'], "old_string" : old_str_of_interest, "new_string" : new_str_of_interest } @@ -460,12 +460,12 @@ class FormatNamingConvention: svs = contract.variables for sv in svs: if (str(sv.type) == contract_name + "." + name): - old_str_of_interest = in_file_str[contract.get_source_var_declaration(sv.name)['start']:(contract.get_source_var_declaration(sv.name)['start']+contract.get_source_var_declaration(sv.name)['length'])] + old_str_of_interest = in_file_str[sv.source_mapping['start']:(sv.source_mapping['start']+sv.source_mapping['length'])] (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(),old_str_of_interest, 1) patch = { "detector" : "naming-convention (enum use)", - "start" : contract.get_source_var_declaration(sv.name)['start'], - "end" : contract.get_source_var_declaration(sv.name)['start'] + contract.get_source_var_declaration(sv.name)['length'], + "start" : sv.source_mapping['start'], + "end" : sv.source_mapping['start'] + sv.source_mapping['length'], "old_string" : old_str_of_interest, "new_string" : new_str_of_interest } @@ -478,12 +478,12 @@ class FormatNamingConvention: # Enum declarations for v in fm.variables: if (str(v.type) == contract_name + "." + name): - old_str_of_interest = in_file_str[fm.get_source_var_declaration(v.name)['start']:(fm.get_source_var_declaration(v.name)['start']+fm.get_source_var_declaration(v.name)['length'])] + old_str_of_interest = in_file_str[v.source_mapping['start']:(v.source_mapping['start']+v.source_mapping['length'])] (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(),old_str_of_interest, 1) patch = { "detector" : "naming-convention (enum use)", - "start" : fm.get_source_var_declaration(v.name)['start'], - "end" : fm.get_source_var_declaration(v.name)['start'] + fm.get_source_var_declaration(v.name)['length'], + "start" : v.source_mapping['start'], + "end" : v.source_mapping['start'] + v.source_mapping['length'], "old_string" : old_str_of_interest, "new_string" : new_str_of_interest } @@ -547,12 +547,12 @@ t']:(node.source_mapping['start']+node.source_mapping['length'])].split('=')[0]) svs = contract.variables for sv in svs: if (str(sv.type) == contract_name + "." + name): - old_str_of_interest = in_file_str[contract.get_source_var_declaration(sv.name)['start']:(contract.get_source_var_declaration(sv.name)['start']+contract.get_source_var_declaration(sv.name)['length'])] + old_str_of_interest = in_file_str[sv.source_mapping['start']:(sv.source_mapping['start']+sv.source_mapping['length'])] (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(),old_str_of_interest, 1) patch = { "detector" : "naming-convention (struct use)", - "start" : contract.get_source_var_declaration(sv.name)['start'], - "end" : contract.get_source_var_declaration(sv.name)['start'] + contract.get_source_var_declaration(sv.name)['length'], + "start" : sv.source_mapping['start'], + "end" : sv.source_mapping['start'] + sv.source_mapping['length'], "old_string" : old_str_of_interest, "new_string" : new_str_of_interest } @@ -564,12 +564,12 @@ t']:(node.source_mapping['start']+node.source_mapping['length'])].split('=')[0]) for fm in fms: for v in fm.variables: if (str(v.type) == contract_name + "." + name): - old_str_of_interest = in_file_str[fm.get_source_var_declaration(v.name)['start']:(fm.get_source_var_declaration(v.name)['start']+fm.get_source_var_declaration(v.name)['length'])] + old_str_of_interest = in_file_str[v.source_mapping['start']:(v.source_mapping['start']+v.source_mapping['length'])] (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(),old_str_of_interest, 1) patch = { "detector" : "naming-convention (struct use)", - "start" : fm.get_source_var_declaration(v.name)['start'], - "end" : fm.get_source_var_declaration(v.name)['start'] + fm.get_source_var_declaration(v.name)['length'], + "start" : v.source_mapping['start'], + "end" : v.source_mapping['start'] + v.source_mapping['length'], "old_string" : old_str_of_interest, "new_string" : new_str_of_interest } From 36afdca50e609052eb66819289bf67000bc570f3 Mon Sep 17 00:00:00 2001 From: rajeevgopalakrishna Date: Tue, 14 May 2019 13:17:11 +0530 Subject: [PATCH 010/223] Changes use of parameters_src and returns_src to source_mapping objects instead of raw source text. --- utils/slither_format/format_constant_function.py | 2 +- utils/slither_format/format_external_function.py | 2 +- utils/slither_format/format_naming_convention.py | 6 +++--- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/utils/slither_format/format_constant_function.py b/utils/slither_format/format_constant_function.py index 13bc725a0..d31f2b47c 100644 --- a/utils/slither_format/format_constant_function.py +++ b/utils/slither_format/format_constant_function.py @@ -13,7 +13,7 @@ class FormatConstantFunction: if not Found: for function in contract.functions: if contract.name == element['contract']['name'] and function.name == element['name']: - FormatConstantFunction.create_patch(slither, patches, element['source_mapping']['filename_absolute'], ["view","pure","constant"], "", int(function.parameters_src.split(':')[0]), int(function.returns_src.split(':')[0])) + FormatConstantFunction.create_patch(slither, patches, element['source_mapping']['filename_absolute'], ["view","pure","constant"], "", int(function.parameters_src.source_mapping['start']), int(function.returns_src.source_mapping['start'])) Found = True @staticmethod diff --git a/utils/slither_format/format_external_function.py b/utils/slither_format/format_external_function.py index 389b0d06b..d9c826e9e 100644 --- a/utils/slither_format/format_external_function.py +++ b/utils/slither_format/format_external_function.py @@ -14,7 +14,7 @@ class FormatExternalFunction: # to external because external function parameters are allocated in calldata region which is # non-modifiable. See https://solidity.readthedocs.io/en/develop/types.html#data-location if not FormatExternalFunction.function_parameters_written(function): - FormatExternalFunction.create_patch(slither, patches, element['source_mapping']['filename_absolute'], "public", "external", int(function.parameters_src.split(':')[0]), int(function.returns_src.split(':')[0])) + FormatExternalFunction.create_patch(slither, patches, element['source_mapping']['filename_absolute'], "public", "external", int(function.parameters_src.source_mapping['start']), int(function.returns_src.source_mapping['start'])) Found = True break diff --git a/utils/slither_format/format_naming_convention.py b/utils/slither_format/format_naming_convention.py index 72b975497..7b868cad7 100644 --- a/utils/slither_format/format_naming_convention.py +++ b/utils/slither_format/format_naming_convention.py @@ -168,13 +168,13 @@ class FormatNamingConvention: for m in function.modifiers: if (m.name == name): in_file_str = slither.source_code[in_file] - old_str_of_interest = in_file_str[int(function.parameters_src.split(':')[0]):int(function.returns_src.split(':')[0])] + old_str_of_interest = in_file_str[int(function.parameters_src.source_mapping['start']):int(function.returns_src.source_mapping['start'])] (new_str_of_interest, num_repl) = re.subn(name, name[0].lower()+name[1:],old_str_of_interest,1) if num_repl != 0: patch = { "detector" : "naming-convention (modifier uses)", - "start" : int(function.parameters_src.split(':')[0]), - "end" : int(function.returns_src.split(':')[0]), + "start" : int(function.parameters_src.source_mapping['start']), + "end" : int(function.returns_src.source_mapping['start']), "old_string" : old_str_of_interest, "new_string" : new_str_of_interest } From a450661cd09e0d1b5ebe7e50f33079e4123acddf Mon Sep 17 00:00:00 2001 From: rajeevgopalakrishna Date: Tue, 14 May 2019 15:42:30 +0530 Subject: [PATCH 011/223] Refined format_constant_function to focus on the specific (view|pure|constant) string. --- .../slither_format/format_constant_function.py | 15 ++++++--------- .../tests/test_constant_function.py | 18 +++++++++--------- 2 files changed, 15 insertions(+), 18 deletions(-) diff --git a/utils/slither_format/format_constant_function.py b/utils/slither_format/format_constant_function.py index d31f2b47c..13aa612ae 100644 --- a/utils/slither_format/format_constant_function.py +++ b/utils/slither_format/format_constant_function.py @@ -20,17 +20,14 @@ class FormatConstantFunction: def create_patch(slither, patches, in_file, match_text, replace_text, modify_loc_start, modify_loc_end): in_file_str = slither.source_code[in_file] old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - for match_text_item in match_text: - (new_str_of_interest, num_repl) = re.subn(match_text_item, replace_text, old_str_of_interest, 1) - if num_repl != 0: - break - if num_repl != 0: + m = re.search("(view|pure|constant)", old_str_of_interest) + if m: patches[in_file].append({ "detector" : "constant-function", - "start" : modify_loc_start, - "end" : modify_loc_end, - "old_string" : old_str_of_interest, - "new_string" : new_str_of_interest + "start" : modify_loc_start + m.span()[0], + "end" : modify_loc_start + m.span()[1], + "old_string" : m.groups(0)[0], + "new_string" : replace_text }) else: print("Error: No view/pure/constant specifier exists. Regex failed to remove specifier!") diff --git a/utils/slither_format/tests/test_constant_function.py b/utils/slither_format/tests/test_constant_function.py index 8d43a0f55..56f8ecf4d 100644 --- a/utils/slither_format/tests/test_constant_function.py +++ b/utils/slither_format/tests/test_constant_function.py @@ -37,14 +37,14 @@ class TestConstantFunctions(unittest.TestCase): self.assertEqual(outFD1_lines[0],"Number of Slither results: 3") self.assertEqual(outFD1_lines[1],"Number of patches: 3") self.assertEqual(outFD1_lines.count("Detector: constant-function"), 3) - self.assertEqual(outFD1_lines.count("Old string: () public view"), 2) - self.assertEqual(outFD1_lines.count("Old string: () public constant"), 1) - self.assertEqual(outFD1_lines.count("New string: () public"), 3) - self.assertEqual(outFD1_lines.count("Location start: 67"), 1) + self.assertEqual(outFD1_lines.count("Old string: view"), 2) + self.assertEqual(outFD1_lines.count("Old string: constant"), 1) + self.assertEqual(outFD1_lines.count("New string:"), 3) + self.assertEqual(outFD1_lines.count("Location start: 77"), 1) self.assertEqual(outFD1_lines.count("Location end: 81"), 1) - self.assertEqual(outFD1_lines.count("Location start: 139"), 1) + self.assertEqual(outFD1_lines.count("Location start: 149"), 1) self.assertEqual(outFD1_lines.count("Location end: 157"), 1) - self.assertEqual(outFD1_lines.count("Location start: 350"), 1) + self.assertEqual(outFD1_lines.count("Location start: 360"), 1) self.assertEqual(outFD1_lines.count("Location end: 364"), 1) outFD1.close() @@ -55,9 +55,9 @@ class TestConstantFunctions(unittest.TestCase): self.assertTrue(os.path.isfile(self.testFilePath2+".format"),"Patched .format file is not created?!") self.assertEqual(outFD2_lines[0],"Number of Slither results: 1") self.assertEqual(outFD2_lines[1],"Number of patches: 1") - self.assertEqual(outFD2_lines.count("Old string: () public view"), 1) - self.assertEqual(outFD2_lines.count("New string: () public"), 1) - self.assertEqual(outFD2_lines.count("Location start: 211"), 1) + self.assertEqual(outFD2_lines.count("Old string: view"), 1) + self.assertEqual(outFD2_lines.count("New string:"), 1) + self.assertEqual(outFD2_lines.count("Location start: 221"), 1) self.assertEqual(outFD2_lines.count("Location end: 225"), 1) outFD2.close() From c2461693da92fbdc6c0473b36f855a988b9aeeee Mon Sep 17 00:00:00 2001 From: rajeevgopalakrishna Date: Tue, 14 May 2019 17:37:11 +0530 Subject: [PATCH 012/223] Simplifies format_external_function to focus on public/implicit visibility specifier. --- .../format_external_function.py | 25 ++++--------- .../tests/test_external_function.py | 37 ++++++++----------- 2 files changed, 23 insertions(+), 39 deletions(-) diff --git a/utils/slither_format/format_external_function.py b/utils/slither_format/format_external_function.py index d9c826e9e..660983077 100644 --- a/utils/slither_format/format_external_function.py +++ b/utils/slither_format/format_external_function.py @@ -22,32 +22,23 @@ class FormatExternalFunction: def create_patch(slither, patches, in_file, match_text, replace_text, modify_loc_start, modify_loc_end): in_file_str = slither.source_code[in_file] old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - old_str_of_interest_beyond_parameters = ')'.join(old_str_of_interest.split(')')[1:]) - s = old_str_of_interest_beyond_parameters.split('(') - if len(s) == 1: - account_for_return = 0 - else: - account_for_return = 1 - old_str_of_interest_beyond_parameters_before_modifier_return = old_str_of_interest_beyond_parameters.split('(')[0] - m = re.search("public", old_str_of_interest_beyond_parameters_before_modifier_return) + m = re.search("public", old_str_of_interest) if m is None: # No visibility specifier exists; public by default. - (new_str_of_interest, _) = re.subn(" ", " external ", old_str_of_interest_beyond_parameters_before_modifier_return, 1) patches[in_file].append({ "detector" : "external-function", "start" : modify_loc_start + len(old_str_of_interest.split(')')[0]) + 1, - "end" : modify_loc_end - len('('.join(old_str_of_interest_beyond_parameters.split('(')[1:])) - account_for_return, - "old_string" : old_str_of_interest_beyond_parameters_before_modifier_return, - "new_string" : new_str_of_interest + "end" : modify_loc_start + len(old_str_of_interest.split(')')[0]) + 1, + "old_string" : "", + "new_string" : " " + replace_text }) else: - (new_str_of_interest, _) = re.subn(match_text, replace_text, old_str_of_interest_beyond_parameters_before_modifier_return, 1) patches[in_file].append({ "detector" : "external-function", - "start" : modify_loc_start + len(old_str_of_interest.split(')')[0]) + 1 + m.span()[0], - "end" : modify_loc_end - len('('.join(old_str_of_interest_beyond_parameters.split('(')[1:])) - account_for_return, - "old_string" : old_str_of_interest_beyond_parameters_before_modifier_return, - "new_string" : new_str_of_interest + "start" : modify_loc_start + m.span()[0], + "end" : modify_loc_start + m.span()[1], + "old_string" : match_text, + "new_string" : replace_text }) @staticmethod diff --git a/utils/slither_format/tests/test_external_function.py b/utils/slither_format/tests/test_external_function.py index b5d5c55b8..46018c161 100644 --- a/utils/slither_format/tests/test_external_function.py +++ b/utils/slither_format/tests/test_external_function.py @@ -37,35 +37,28 @@ class TestExternalFunctions(unittest.TestCase): self.assertEqual(outFD1_lines[0],"Number of Slither results: 9") self.assertEqual(outFD1_lines[1],"Number of patches: 8") self.assertEqual(outFD1_lines.count("Detector: external-function"), 8) - self.assertEqual(outFD1_lines.count("Old string: public returns"), 1) - self.assertEqual(outFD1_lines.count("New string: external returns"), 1) + self.assertEqual(outFD1_lines.count("Old string: public"), 6) + self.assertEqual(outFD1_lines.count("New string: external"), 6) self.assertEqual(outFD1_lines.count("Location start: 384"), 1) - self.assertEqual(outFD1_lines.count("Location end: 399"), 1) - self.assertEqual(outFD1_lines.count("Old string:"), 1) - self.assertEqual(outFD1_lines.count("New string: external"), 4) - self.assertEqual(outFD1_lines.count("Location start: 524"), 1) - self.assertEqual(outFD1_lines.count("Location end: 525"), 1) - self.assertEqual(outFD1_lines.count("Old string: public returns"), 1) - self.assertEqual(outFD1_lines.count("New string: external returns"), 1) + self.assertEqual(outFD1_lines.count("Location end: 390"), 1) self.assertEqual(outFD1_lines.count("Location start: 562"), 1) - self.assertEqual(outFD1_lines.count("Location end: 581"), 1) - self.assertEqual(outFD1_lines.count("Old string: public"), 3) - self.assertEqual(outFD1_lines.count("Old string: public mod"), 1) - self.assertEqual(outFD1_lines.count("New string: external"), 4) + self.assertEqual(outFD1_lines.count("Location end: 568"), 1) self.assertEqual(outFD1_lines.count("Location start: 642"), 1) - self.assertEqual(outFD1_lines.count("Location end: 649"), 1) + self.assertEqual(outFD1_lines.count("Location end: 648"), 1) self.assertEqual(outFD1_lines.count("Location start: 685"), 1) - self.assertEqual(outFD1_lines.count("Location end: 692"), 1) + self.assertEqual(outFD1_lines.count("Location end: 691"), 1) self.assertEqual(outFD1_lines.count("Location start: 1022"), 1) - self.assertEqual(outFD1_lines.count("Location end: 1033"), 1) - self.assertEqual(outFD1_lines.count("Location start: 1142"), 1) - self.assertEqual(outFD1_lines.count("Location end: 1147"), 1) - self.assertEqual(outFD1_lines.count("Old string: mod"), 1) - self.assertEqual(outFD1_lines.count("New string: external mod"), 2) + self.assertEqual(outFD1_lines.count("Location end: 1028"), 1) self.assertEqual(outFD1_lines.count("Location start: 1305"), 1) - self.assertEqual(outFD1_lines.count("Location end: 1312"), 1) + self.assertEqual(outFD1_lines.count("Location end: 1311"), 1) + self.assertEqual(outFD1_lines.count("Old string:"), 2) + self.assertEqual(outFD1_lines.count("New string: external"), 2) + self.assertEqual(outFD1_lines.count("Location start: 524"), 1) + self.assertEqual(outFD1_lines.count("Location end: 524"), 1) + self.assertEqual(outFD1_lines.count("Location start: 1142"), 1) + self.assertEqual(outFD1_lines.count("Location end: 1142"), 1) outFD1.close() - + outFD2 = open(self.testFilePath2+".out","r") outFD2_lines = outFD2.readlines() for i in range(len(outFD2_lines)): From 993418b2f499022675f9c725e196620425e1fac5 Mon Sep 17 00:00:00 2001 From: rajeevgopalakrishna Date: Wed, 15 May 2019 10:15:26 +0530 Subject: [PATCH 013/223] Updates .gitignore to exclude emacs backup files ending in ~ --- utils/slither_format/.gitignore | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/utils/slither_format/.gitignore b/utils/slither_format/.gitignore index c51eb4dee..f5478e79f 100644 --- a/utils/slither_format/.gitignore +++ b/utils/slither_format/.gitignore @@ -1 +1,9 @@ +# .format files are the output files produced by slither-format *.format + +# Temporary files (Emacs backup files ending in tilde and others) +*~ + + + + From d2422dc649f2dc22d1cda4770085a5b0904e099b Mon Sep 17 00:00:00 2001 From: rajeevgopalakrishna Date: Wed, 15 May 2019 11:53:28 +0530 Subject: [PATCH 014/223] Adds README.md --- utils/slither_format/README.md | 57 ++++++++++++++++++++++++++++++++++ 1 file changed, 57 insertions(+) create mode 100644 utils/slither_format/README.md diff --git a/utils/slither_format/README.md b/utils/slither_format/README.md new file mode 100644 index 000000000..f86c9a498 --- /dev/null +++ b/utils/slither_format/README.md @@ -0,0 +1,57 @@ +# Slither-format: Automatic Code Improvements + +Slither-format is a Slither utility tool which uses Slither detectors to identify code patterns of concern (w.r.t security, readability and optimisation) and automatically fix those code patterns with suggested changes. + +Slither detectors highlight names, context and source-mapping of code constructs which are then used by Slither-format to programmatically locate those constructs in the Solidity files and then replace them with changes based on best practices. Lexical analysis for identification of such constructs is confined to the smallest possible region to avoid conflicts with similarly named constructs (with potentially different types or signatures) in other scopes, functions or contracts within the same file (because of shadowing, overloading etc.). + +## Features + +* Removes declarations of unused state variables +* Changes the visibility of `public` (explicit or implicit until solc 0.5.0) functions to `external` where possible +* Declares state variables as `constant` where possible +* Removes `pure`/`view`/`constant` attributes of functions when they are incorrectly used +* Replaces old/buggy/too-recent versions of `solc` with either `0.4.25` or `0.5.3` +* Replaces use of different `solc` versions with either `0.4.25` or `0.5.3` +* Replaces names of various program constructs to adhere to Solidity [naming convention](https://solidity.readthedocs.io/en/v0.4.25/style-guide.html#naming-conventions): + + Contract names are converted to CapWords in contract definitions and uses + + Structure names are converted to CapWords in structure declarations and uses + + Event names are converted to CapWords in event declarations and calls + + Enum names are converted to CapWords in enum declarations and uses + + State variables: + + If constant, are converted to UPPERCASE + + If private, are converted to mixedCase with underscore + + If not private, are converted to mixedCase + + Function names are converted to mixedCase in function definitions and calls + + Function parameters are converted to CapWords beginning with underscores in parameter declaration and uses + + Function modifiers are converted to mixedCase in modifier definitions and calls + +## Usage + +Run Slither-format on a single file: +``` +$ python3 -m slither-format ./utils/slither_format/tests/test_data/constant.sol +``` + +This produces `constant.sol.format` file which has all the feature replacements. + +## Dependencies + +Slither-format requires Slither and all its dependencies + +## Known Limitations + +* Naming convention formatting on parameter uses does not work for NatSpec @param attributes +* Naming convention formatting on parameter uses does not work for variables used as indices on LHS (e.g. `_to` in `balances[_to] = 100`) + +## Developer Testing + +``` +$ python3 ./slither_format/tests/test_unused_state_vars.py +$ python3 ./slither_format/tests/test_external_function.py +$ python3 ./slither_format/tests/test_constable_states.py +$ python3 ./slither_format/tests/test_constant_function.py +$ python3 ./slither_format/tests/test_solc_version.py +$ python3 ./slither_format/tests/test_pragma.py +$ python3 ./slither_format/tests/test_naming_convention.py +$ python3 ./slither_format/tests/run_all_tests.py +``` From 92792bcdb315b06bc3d4c483b4fa743155549a1e Mon Sep 17 00:00:00 2001 From: rajeevgopalakrishna Date: Wed, 15 May 2019 13:06:18 +0530 Subject: [PATCH 015/223] Adds minor formatting edits to README.md --- utils/slither_format/README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/utils/slither_format/README.md b/utils/slither_format/README.md index f86c9a498..c3f291655 100644 --- a/utils/slither_format/README.md +++ b/utils/slither_format/README.md @@ -19,8 +19,8 @@ Slither detectors highlight names, context and source-mapping of code constructs + Enum names are converted to CapWords in enum declarations and uses + State variables: + If constant, are converted to UPPERCASE - + If private, are converted to mixedCase with underscore - + If not private, are converted to mixedCase + + If private, are converted to mixedCase with underscore + + If not private, are converted to mixedCase + Function names are converted to mixedCase in function definitions and calls + Function parameters are converted to CapWords beginning with underscores in parameter declaration and uses + Function modifiers are converted to mixedCase in modifier definitions and calls From 2c987ad250c3107323a55c008dd21efd6cf9761d Mon Sep 17 00:00:00 2001 From: rajeevgopalakrishna Date: Wed, 15 May 2019 15:35:10 +0530 Subject: [PATCH 016/223] Corrects list of available detectors for usage --help --- utils/slither_format/__main__.py | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/utils/slither_format/__main__.py b/utils/slither_format/__main__.py index a3b0af4f9..88b1b9e54 100644 --- a/utils/slither_format/__main__.py +++ b/utils/slither_format/__main__.py @@ -8,7 +8,14 @@ from .slither_format import slither_format logging.basicConfig() logging.getLogger("Slither").setLevel(logging.INFO) -available_detectors = ["external-function"] +available_detectors = ["unused-state", + "solc-version", + "pragma", + "naming-convention", + "external-function", + "constable-states", + "constant-function"] + detectors_to_run = [] def parse_args(): From f60e4d4915e09980d49db65c98f6850a9d1d77b5 Mon Sep 17 00:00:00 2001 From: rajeevgopalakrishna Date: Wed, 15 May 2019 18:09:41 +0530 Subject: [PATCH 017/223] Adds --verbose-json option to print patches in json format. The earlier --verbose option is now --verbose-test for use with unit tests. --- utils/slither_format/__main__.py | 3 +- utils/slither_format/slither_format.py | 38 +++++++++++++++++-- .../tests/test_constable_states.py | 2 +- .../tests/test_constant_function.py | 4 +- .../tests/test_external_function.py | 4 +- .../tests/test_naming_convention.py | 16 ++++---- utils/slither_format/tests/test_pragma.py | 4 +- .../slither_format/tests/test_solc_version.py | 8 ++-- .../tests/test_unused_state_vars.py | 2 +- 9 files changed, 56 insertions(+), 25 deletions(-) diff --git a/utils/slither_format/__main__.py b/utils/slither_format/__main__.py index 88b1b9e54..0c4292618 100644 --- a/utils/slither_format/__main__.py +++ b/utils/slither_format/__main__.py @@ -28,7 +28,8 @@ def parse_args(): parser.add_argument('filename', help='The filename of the contract or truffle directory to analyze.') parser.add_argument('--solc', help='solc path', default='solc') - parser.add_argument('--verbose', '-v', help='verbose mode output',action='store_true',default=False) + parser.add_argument('--verbose-test', '-v', help='verbose mode output for testing',action='store_true',default=False) + parser.add_argument('--verbose-json', '-j', help='verbose json output',action='store_true',default=False) group_detector = parser.add_argument_group('Detectors') group_detector.add_argument('--detect', diff --git a/utils/slither_format/slither_format.py b/utils/slither_format/slither_format.py index e29713acf..f065cee47 100644 --- a/utils/slither_format/slither_format.py +++ b/utils/slither_format/slither_format.py @@ -42,9 +42,10 @@ def slither_format(args, slither): number_of_slither_results = get_number_of_slither_results(detector_results) apply_detector_results(slither, patches, detector_results) sort_patches(patches) - if args.verbose: - print("Number of Slither results: " + str(number_of_slither_results)) - print_patches(patches) + if args.verbose_json: + print_patches_json(number_of_slither_results, patches) + if args.verbose_test: + print_patches(number_of_slither_results, patches) apply_patches(slither, patches) def sort_patches(patches): @@ -73,7 +74,8 @@ def apply_patches(slither, patches): out_file.write(out_file_str) out_file.close() -def print_patches(patches): +def print_patches(number_of_slither_results, patches): + print("Number of Slither results: " + str(number_of_slither_results)) number_of_patches = 0 for file in patches: number_of_patches += len(patches[file]) @@ -87,6 +89,34 @@ def print_patches(patches): print("Location start: " + str(patch['start'])) print("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']) + '"') + print('}',end='') + print(']',end='') + print('}',end='') + print(']',end='') + print('}') + + def choose_detectors(args): # If detectors are specified, run only these ones detectors_to_run = [] diff --git a/utils/slither_format/tests/test_constable_states.py b/utils/slither_format/tests/test_constable_states.py index cd4d1891b..6921485de 100644 --- a/utils/slither_format/tests/test_constable_states.py +++ b/utils/slither_format/tests/test_constable_states.py @@ -9,7 +9,7 @@ class TestConstableState(unittest.TestCase): def setUp(self): outFD = open(self.testFilePath+".out","w") errFD = open(self.testFilePath+".err","w") - p = subprocess.Popen(['python3', '-m', 'slither_format','--verbose','--detect','constable-states',self.testFilePath], stdout=outFD,stderr=errFD) + p = subprocess.Popen(['python3', '-m', 'slither_format','--verbose-test','--detect','constable-states',self.testFilePath], stdout=outFD,stderr=errFD) p.wait() outFD.close() errFD.close() diff --git a/utils/slither_format/tests/test_constant_function.py b/utils/slither_format/tests/test_constant_function.py index 56f8ecf4d..8fe337726 100644 --- a/utils/slither_format/tests/test_constant_function.py +++ b/utils/slither_format/tests/test_constant_function.py @@ -11,11 +11,11 @@ class TestConstantFunctions(unittest.TestCase): def setUp(self): outFD1 = open(self.testFilePath1+".out","w") errFD1 = open(self.testFilePath1+".err","w") - p1 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose','--detect','constant-function',self.testFilePath1], stdout=outFD1,stderr=errFD1) + p1 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose-test','--detect','constant-function',self.testFilePath1], stdout=outFD1,stderr=errFD1) p1.wait() outFD2 = open(self.testFilePath2+".out","w") errFD2 = open(self.testFilePath2+".err","w") - p2 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose','--detect','constant-function',self.testFilePath2], stdout=outFD2,stderr=errFD2) + p2 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose-test','--detect','constant-function',self.testFilePath2], stdout=outFD2,stderr=errFD2) p2.wait() outFD1.close() errFD1.close() diff --git a/utils/slither_format/tests/test_external_function.py b/utils/slither_format/tests/test_external_function.py index 46018c161..32ccdedef 100644 --- a/utils/slither_format/tests/test_external_function.py +++ b/utils/slither_format/tests/test_external_function.py @@ -11,11 +11,11 @@ class TestExternalFunctions(unittest.TestCase): def setUp(self): outFD1 = open(self.testFilePath1+".out","w") errFD1 = open(self.testFilePath1+".err","w") - p1 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose','--detect','external-function',self.testFilePath1], stdout=outFD1,stderr=errFD1) + p1 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose-test','--detect','external-function',self.testFilePath1], stdout=outFD1,stderr=errFD1) p1.wait() outFD2 = open(self.testFilePath2+".out","w") errFD2 = open(self.testFilePath2+".err","w") - p2 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose','--detect','external-function',self.testFilePath2], stdout=outFD2,stderr=errFD2) + p2 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose-test','--detect','external-function',self.testFilePath2], stdout=outFD2,stderr=errFD2) p2.wait() outFD1.close() errFD1.close() diff --git a/utils/slither_format/tests/test_naming_convention.py b/utils/slither_format/tests/test_naming_convention.py index bd9088b8a..b5f253dac 100644 --- a/utils/slither_format/tests/test_naming_convention.py +++ b/utils/slither_format/tests/test_naming_convention.py @@ -23,56 +23,56 @@ class TestNamingConvention(unittest.TestCase): def setUp(self): outFD1 = open(self.testFilePath1+".out","w") errFD1 = open(self.testFilePath1+".err","w") - p1 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose','--detect','naming-convention',self.testFilePath1], stdout=outFD1,stderr=errFD1) + p1 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose-test','--detect','naming-convention',self.testFilePath1], stdout=outFD1,stderr=errFD1) p1.wait() outFD1.close() errFD1.close() outFD2 = open(self.testFilePath2+".out","w") errFD2 = open(self.testFilePath2+".err","w") - p2 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose','--detect','naming-convention',self.testFilePath2], stdout=outFD2,stderr=errFD2) + p2 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose-test','--detect','naming-convention',self.testFilePath2], stdout=outFD2,stderr=errFD2) p2.wait() outFD2.close() errFD2.close() outFD3 = open(self.testFilePath3+".out","w") errFD3 = open(self.testFilePath3+".err","w") - p3 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose','--detect','naming-convention',self.testFilePath3], stdout=outFD3,stderr=errFD3) + p3 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose-test','--detect','naming-convention',self.testFilePath3], stdout=outFD3,stderr=errFD3) p3.wait() outFD3.close() errFD3.close() outFD4 = open(self.testFilePath4+".out","w") errFD4 = open(self.testFilePath4+".err","w") - p4 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose','--detect','naming-convention',self.testFilePath4], stdout=outFD4,stderr=errFD4) + p4 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose-test','--detect','naming-convention',self.testFilePath4], stdout=outFD4,stderr=errFD4) p4.wait() outFD4.close() errFD4.close() outFD5 = open(self.testFilePath5+".out","w") errFD5 = open(self.testFilePath5+".err","w") - p5 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose','--detect','naming-convention',self.testFilePath5], stdout=outFD5,stderr=errFD5) + p5 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose-test','--detect','naming-convention',self.testFilePath5], stdout=outFD5,stderr=errFD5) p5.wait() outFD5.close() errFD5.close() outFD6 = open(self.testFilePath6+".out","w") errFD6 = open(self.testFilePath6+".err","w") - p6 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose','--detect','naming-convention',self.testFilePath6], stdout=outFD6,stderr=errFD6) + p6 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose-test','--detect','naming-convention',self.testFilePath6], stdout=outFD6,stderr=errFD6) p6.wait() outFD6.close() errFD6.close() outFD7 = open(self.testFilePath7+".out","w") errFD7 = open(self.testFilePath7+".err","w") - p7 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose','--detect','naming-convention',self.testFilePath7], stdout=outFD7,stderr=errFD7) + p7 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose-test','--detect','naming-convention',self.testFilePath7], stdout=outFD7,stderr=errFD7) p7.wait() outFD7.close() errFD7.close() outFD8 = open(self.testFilePath8+".out","w") errFD8 = open(self.testFilePath8+".err","w") - p8 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose','--detect','naming-convention',self.testFilePath8], stdout=outFD8,stderr=errFD8) + p8 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose-test','--detect','naming-convention',self.testFilePath8], stdout=outFD8,stderr=errFD8) p8.wait() outFD8.close() errFD8.close() diff --git a/utils/slither_format/tests/test_pragma.py b/utils/slither_format/tests/test_pragma.py index 1d1e7c1c3..ea9ec60b4 100644 --- a/utils/slither_format/tests/test_pragma.py +++ b/utils/slither_format/tests/test_pragma.py @@ -15,7 +15,7 @@ class TestPragma(unittest.TestCase): def setUp(self): outFD1 = open(self.testFilePath1+".out","w") errFD1 = open(self.testFilePath1+".err","w") - p1 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose','--detect','pragma',self.testFilePath1], stdout=outFD1,stderr=errFD1) + p1 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose-test','--detect','pragma',self.testFilePath1], stdout=outFD1,stderr=errFD1) p1.wait() outFD1.close() errFD1.close() @@ -24,7 +24,7 @@ class TestPragma(unittest.TestCase): errFD2 = open(self.testFilePath2+".err","w") my_env = os.environ.copy() my_env["SOLC_VERSION"] = "0.5.4" - p2 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose','--detect','pragma',self.testFilePath2], stdout=outFD2,stderr=errFD2, env=my_env) + p2 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose-test','--detect','pragma',self.testFilePath2], stdout=outFD2,stderr=errFD2, env=my_env) p2.wait() outFD2.close() errFD2.close() diff --git a/utils/slither_format/tests/test_solc_version.py b/utils/slither_format/tests/test_solc_version.py index c2d6eb2cc..16a9ea34a 100644 --- a/utils/slither_format/tests/test_solc_version.py +++ b/utils/slither_format/tests/test_solc_version.py @@ -15,21 +15,21 @@ class TestSolcVersion(unittest.TestCase): def setUp(self): outFD1 = open(self.testFilePath1+".out","w") errFD1 = open(self.testFilePath1+".err","w") - p1 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose','--detect','solc-version',self.testFilePath1], stdout=outFD1,stderr=errFD1) + p1 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose-test','--detect','solc-version',self.testFilePath1], stdout=outFD1,stderr=errFD1) p1.wait() outFD1.close() errFD1.close() outFD2 = open(self.testFilePath2+".out","w") errFD2 = open(self.testFilePath2+".err","w") - p2 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose','--detect','solc-version',self.testFilePath2], stdout=outFD2,stderr=errFD2) + p2 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose-test','--detect','solc-version',self.testFilePath2], stdout=outFD2,stderr=errFD2) p2.wait() outFD2.close() errFD2.close() outFD3 = open(self.testFilePath3+".out","w") errFD3 = open(self.testFilePath3+".err","w") - p3 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose','--detect','solc-version',self.testFilePath3], stdout=outFD3,stderr=errFD3) + p3 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose-test','--detect','solc-version',self.testFilePath3], stdout=outFD3,stderr=errFD3) p3.wait() outFD3.close() errFD3.close() @@ -38,7 +38,7 @@ class TestSolcVersion(unittest.TestCase): errFD4 = open(self.testFilePath4+".err","w") my_env = os.environ.copy() my_env["SOLC_VERSION"] = "0.5.2" - p4 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose','--detect','solc-version',self.testFilePath4], stdout=outFD4,stderr=errFD4, env=my_env) + p4 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose-test','--detect','solc-version',self.testFilePath4], stdout=outFD4,stderr=errFD4, env=my_env) p4.wait() outFD4.close() errFD4.close() diff --git a/utils/slither_format/tests/test_unused_state_vars.py b/utils/slither_format/tests/test_unused_state_vars.py index ee329aa38..d290fc38a 100644 --- a/utils/slither_format/tests/test_unused_state_vars.py +++ b/utils/slither_format/tests/test_unused_state_vars.py @@ -9,7 +9,7 @@ class TestUnusedStateVars(unittest.TestCase): def setUp(self): outFD = open(self.testFilePath+".out","w") errFD = open(self.testFilePath+".err","w") - p = subprocess.Popen(['python3', '-m', 'slither_format','--verbose','--detect','unused-state',self.testFilePath], stdout=outFD,stderr=errFD) + p = subprocess.Popen(['python3', '-m', 'slither_format','--verbose-test','--detect','unused-state',self.testFilePath], stdout=outFD,stderr=errFD) p.wait() outFD.close() errFD.close() From 3e68ffc8a2395afc05526339876a9eb42f88e79a Mon Sep 17 00:00:00 2001 From: rajeevgopalakrishna Date: Thu, 16 May 2019 11:43:20 +0530 Subject: [PATCH 018/223] Adds overlapping patch detection and pruning. Adds a test for detector combinations. --- utils/slither_format/slither_format.py | 32 +++++++++++-- utils/slither_format/tests/run_all_tests.py | 2 + .../tests/test_data/detector_combinations.sol | 48 +++++++++++++++++++ .../tests/test_detector_combinations.py | 40 ++++++++++++++++ 4 files changed, 119 insertions(+), 3 deletions(-) create mode 100644 utils/slither_format/tests/test_data/detector_combinations.sol create mode 100644 utils/slither_format/tests/test_detector_combinations.py diff --git a/utils/slither_format/slither_format.py b/utils/slither_format/slither_format.py index f065cee47..86bdf0660 100644 --- a/utils/slither_format/slither_format.py +++ b/utils/slither_format/slither_format.py @@ -41,23 +41,47 @@ def slither_format(args, slither): results.extend(detector_results) number_of_slither_results = get_number_of_slither_results(detector_results) apply_detector_results(slither, patches, detector_results) - sort_patches(patches) + 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) apply_patches(slither, patches) -def sort_patches(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): - if int(patches[file][j]['start']) >= int(patches[file][j+1]['end']): + # 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 + if (int(patches[file][j]['start']) >= int(patches[file][j+1]['start']) and + int(patches[file][j]['start']) <= int(patches[file][j+1]['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: + print("Overlapping patch won't be applied!") + print("xDetector: " + patch['detector']) + print("xOld string: " + patch['old_string'].replace("\n","")) + print("xNew string: " + patch['new_string'].replace("\n","")) + print("xLocation start: " + str(patch['start'])) + print("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 apply_patches(slither, patches): for file in patches: _in_file = file @@ -110,6 +134,8 @@ def print_patches_json(number_of_slither_results, patches): 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='') diff --git a/utils/slither_format/tests/run_all_tests.py b/utils/slither_format/tests/run_all_tests.py index 935de5408..87ac64d20 100644 --- a/utils/slither_format/tests/run_all_tests.py +++ b/utils/slither_format/tests/run_all_tests.py @@ -14,4 +14,6 @@ p6 = subprocess.Popen(['python3', './slither_format/tests/test_pragma.py']) p6.wait() p7 = subprocess.Popen(['python3', './slither_format/tests/test_solc_version.py']) p7.wait() +p8 = subprocess.Popen(['python3', './slither_format/tests/test_detector_combinations.py']) +p8.wait() diff --git a/utils/slither_format/tests/test_data/detector_combinations.sol b/utils/slither_format/tests/test_data/detector_combinations.sol new file mode 100644 index 000000000..99011adcf --- /dev/null +++ b/utils/slither_format/tests/test_data/detector_combinations.sol @@ -0,0 +1,48 @@ +pragma solidity ^0.4.24; + +contract A { + + /* constant state variable naming - bad */ + /* unused state variable - bad */ + /* Overlapping detectors - so neither will be applied for now */ + uint max_tx = 100; + + /* state variable declaration naming convention - bad */ + uint SV_count = 0; + + modifier mod (uint c) { + require (c > 100); + _; + } + + /* parameter declaration naming convention - bad */ + function foo(uint Count) { + /* parameter use naming convention- bad */ + /* state variable use naming convention - bad */ + SV_count = Count; + } + + /* implicitly public, can be made external - bad */ + /* parameter declarations naming convention - bad */ + function foobar(uint Count, uint Number) returns (uint) { + /* parameter use naming convention - bad */ + foo (Number); + /* parameter use naming convention - bad */ + return (Count+Number); + } + + /* explicitly public, can be made external - bad */ + /* view but modifies state - bad */ + /* parameter declarations naming convention - bad */ + /* parameter use passed to modifier naming convention - bad */ + function bar(uint Count) public view mod (Count) returns(uint) { + /* Use of state variable naming convention - bad */ + /* Use of parameter naming convention - bad */ + SV_count += Count; + /* Use of state variable naming convention - bad */ + return (SV_count); + } + +} + + diff --git a/utils/slither_format/tests/test_detector_combinations.py b/utils/slither_format/tests/test_detector_combinations.py new file mode 100644 index 000000000..10e60a082 --- /dev/null +++ b/utils/slither_format/tests/test_detector_combinations.py @@ -0,0 +1,40 @@ +import unittest +import subprocess, os, sys + +class TestDetectorCombinations(unittest.TestCase): + testDataDir = "./slither_format/tests/test_data/" + testDataFile1 = "detector_combinations.sol" + testFilePath1 = testDataDir+testDataFile1 + + def setUp(self): + outFD1 = open(self.testFilePath1+".out","w") + errFD1 = open(self.testFilePath1+".err","w") + p1 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose-test',self.testFilePath1], stdout=outFD1,stderr=errFD1) + p1.wait() + outFD1.close() + errFD1.close() + + def tearDown(self): + p1 = subprocess.Popen(['rm','-f',self.testFilePath1+'.out',self.testFilePath1+'.err',self.testFilePath1+'.format']) + p1.wait() + + def test_detector_combinations(self): + outFD1 = open(self.testFilePath1+".out","r") + outFD1_lines = outFD1.readlines() + outFD1.close() + for i in range(len(outFD1_lines)): + outFD1_lines[i] = outFD1_lines[i].strip() + self.assertTrue(os.path.isfile(self.testFilePath1+".format"),"Patched .format file is not created?!") + self.assertEqual(outFD1_lines.count("Number of Slither results: 11"), 1) + self.assertEqual(outFD1_lines.count("Number of patches: 18"), 1) + self.assertEqual(outFD1_lines.count("Overlapping patch won't be applied!"), 2) + self.assertEqual(outFD1_lines.count("xDetector: unused-state"), 1) + self.assertEqual(outFD1_lines.count("xDetector: constable-states"), 1) + self.assertEqual(outFD1_lines.count("Detector: naming-convention (state variable declaration)"), 2) + self.assertEqual(outFD1_lines.count("Detector: naming-convention (state variable uses)"), 3) + self.assertEqual(outFD1_lines.count("Detector: naming-convention (parameter declaration)"), 4) + self.assertEqual(outFD1_lines.count("Detector: naming-convention (parameter uses)"), 6) + self.assertEqual(outFD1_lines.count("Detector: external-function"), 2) + self.assertEqual(outFD1_lines.count("Detector: constant-function"), 1) +if __name__ == '__main__': + unittest.main() From 2724365c60f85fabda01cb0b6bac0a4538ae3a09 Mon Sep 17 00:00:00 2001 From: rajeevgopalakrishna Date: Thu, 16 May 2019 16:21:10 +0530 Subject: [PATCH 019/223] Adds support for inheritance in naming-convention of state variables. --- .../format_naming_convention.py | 3 ++ ..._convention_state_variable_inheritance.sol | 37 ++++++++++++++ .../tests/test_naming_convention.py | 49 ++++++++++++++++++- 3 files changed, 88 insertions(+), 1 deletion(-) create mode 100644 utils/slither_format/tests/test_data/naming_convention_state_variable_inheritance.sol diff --git a/utils/slither_format/format_naming_convention.py b/utils/slither_format/format_naming_convention.py index 7b868cad7..7ebbd3b59 100644 --- a/utils/slither_format/format_naming_convention.py +++ b/utils/slither_format/format_naming_convention.py @@ -402,6 +402,9 @@ class FormatNamingConvention: # To-do: Check cross-contract state variable uses for contract in slither.contracts: if (contract.name == contract_name): + target_contract = contract + for contract in slither.contracts: + if (contract == target_contract or (contract in target_contract.derived_contracts)): fms = contract.functions + contract.modifiers for fm in fms: for node in fm.nodes: diff --git a/utils/slither_format/tests/test_data/naming_convention_state_variable_inheritance.sol b/utils/slither_format/tests/test_data/naming_convention_state_variable_inheritance.sol new file mode 100644 index 000000000..2e7239f71 --- /dev/null +++ b/utils/slither_format/tests/test_data/naming_convention_state_variable_inheritance.sol @@ -0,0 +1,37 @@ +pragma solidity ^0.4.24; + +contract A { + /* State variable declaration constant - good */ + uint constant NUMBER = 100; + /* State variable declaration private - good */ + uint private count = 100; + /* State variable declaration non-constant non-private - good */ + uint maxnum = 999; + + function foo() { + /* State variable uses - good */ + uint i = NUMBER + count + maxnum; + } +} + +contract B { + /* State variable declaration constant - bad */ + uint constant number = 100; + /* State variable declaration private - bad */ + uint private Count = 100; + /* State variable declaration non-constant non-private - good */ + uint Maxnum = 999; + function foo() { + /* State variable uses - bad */ + uint i = number + Count + Maxnum; + Count += i; + } +} + +contract C is B { + function foo() { + /* State variable uses - bad */ + uint i = number + Maxnum; + } +} + diff --git a/utils/slither_format/tests/test_naming_convention.py b/utils/slither_format/tests/test_naming_convention.py index b5f253dac..358282f66 100644 --- a/utils/slither_format/tests/test_naming_convention.py +++ b/utils/slither_format/tests/test_naming_convention.py @@ -11,6 +11,7 @@ class TestNamingConvention(unittest.TestCase): testDataFile6 = "naming_convention_function.sol" testDataFile7 = "naming_convention_parameter.sol" testDataFile8 = "naming_convention_state_variable.sol" + testDataFile9 = "naming_convention_state_variable_inheritance.sol" testFilePath1 = testDataDir+testDataFile1 testFilePath2 = testDataDir+testDataFile2 testFilePath3 = testDataDir+testDataFile3 @@ -19,6 +20,7 @@ class TestNamingConvention(unittest.TestCase): testFilePath6 = testDataDir+testDataFile6 testFilePath7 = testDataDir+testDataFile7 testFilePath8 = testDataDir+testDataFile8 + testFilePath9 = testDataDir+testDataFile9 def setUp(self): outFD1 = open(self.testFilePath1+".out","w") @@ -77,6 +79,13 @@ class TestNamingConvention(unittest.TestCase): outFD8.close() errFD8.close() + outFD9 = open(self.testFilePath9+".out","w") + errFD9 = open(self.testFilePath9+".err","w") + p8 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose-test','--detect','naming-convention',self.testFilePath9], stdout=outFD9,stderr=errFD9) + p8.wait() + outFD9.close() + errFD9.close() + def tearDown(self): p1 = subprocess.Popen(['rm','-f',self.testFilePath1+'.out',self.testFilePath1+'.err',self.testFilePath1+'.format']) p1.wait() @@ -94,7 +103,45 @@ class TestNamingConvention(unittest.TestCase): p7.wait() p8 = subprocess.Popen(['rm','-f',self.testFilePath8+'.out',self.testFilePath8+'.err',self.testFilePath8+'.format']) p8.wait() - + p9 = subprocess.Popen(['rm','-f',self.testFilePath9+'.out',self.testFilePath9+'.err',self.testFilePath9+'.format']) + p9.wait() + + def test_naming_convention_state_variable_inheritance(self): + outFD9 = open(self.testFilePath9+".out","r") + outFD9_lines = outFD9.readlines() + outFD9.close() + for i in range(len(outFD9_lines)): + outFD9_lines[i] = outFD9_lines[i].strip() + self.assertTrue(os.path.isfile(self.testFilePath9+".format"),"Patched .format file is not created?!") + self.assertEqual(outFD9_lines[0],"Number of Slither results: 3") + self.assertEqual(outFD9_lines[1],"Number of patches: 9") + self.assertEqual(outFD9_lines.count("Detector: naming-convention (state variable declaration)"), 3) + self.assertEqual(outFD9_lines.count("Detector: naming-convention (state variable uses)"), 6) + self.assertEqual(outFD9_lines.count("Old string: number"), 3) + self.assertEqual(outFD9_lines.count("New string: NUMBER"), 3) + self.assertEqual(outFD9_lines.count("Location start: 469"), 1) + self.assertEqual(outFD9_lines.count("Location end: 475"), 1) + self.assertEqual(outFD9_lines.count("Location start: 716"), 1) + self.assertEqual(outFD9_lines.count("Location end: 722"), 1) + self.assertEqual(outFD9_lines.count("Location start: 850"), 1) + self.assertEqual(outFD9_lines.count("Location end: 856"), 1) + self.assertEqual(outFD9_lines.count("Old string: Count"), 3) + self.assertEqual(outFD9_lines.count("New string: count"), 3) + self.assertEqual(outFD9_lines.count("Location start: 547"), 1) + self.assertEqual(outFD9_lines.count("Location end: 552"), 1) + self.assertEqual(outFD9_lines.count("Location start: 725"), 1) + self.assertEqual(outFD9_lines.count("Location end: 730"), 1) + self.assertEqual(outFD9_lines.count("Location start: 745"), 1) + self.assertEqual(outFD9_lines.count("Location end: 750"), 1) + self.assertEqual(outFD9_lines.count("Old string: Maxnum"), 3) + self.assertEqual(outFD9_lines.count("New string: maxnum"), 3) + self.assertEqual(outFD9_lines.count("Location start: 634"), 1) + self.assertEqual(outFD9_lines.count("Location end: 640"), 1) + self.assertEqual(outFD9_lines.count("Location start: 733"), 1) + self.assertEqual(outFD9_lines.count("Location end: 739"), 1) + self.assertEqual(outFD9_lines.count("Location start: 859"), 1) + self.assertEqual(outFD9_lines.count("Location end: 865"), 1) + def test_naming_convention_contract(self): outFD1 = open(self.testFilePath1+".out","r") outFD1_lines = outFD1.readlines() From f8a07a90e181f174434016c8afe715acf9b2bb2f Mon Sep 17 00:00:00 2001 From: rajeevgopalakrishna Date: Thu, 16 May 2019 17:37:11 +0530 Subject: [PATCH 020/223] Moves the inheritance testing to existing test. --- utils/slither_format/.gitignore | 3 + .../naming_convention_state_variable.sol | 7 +++ ..._convention_state_variable_inheritance.sol | 37 ----------- .../tests/test_naming_convention.py | 63 +++---------------- 4 files changed, 20 insertions(+), 90 deletions(-) delete mode 100644 utils/slither_format/tests/test_data/naming_convention_state_variable_inheritance.sol diff --git a/utils/slither_format/.gitignore b/utils/slither_format/.gitignore index f5478e79f..d356da7f4 100644 --- a/utils/slither_format/.gitignore +++ b/utils/slither_format/.gitignore @@ -3,6 +3,9 @@ # Temporary files (Emacs backup files ending in tilde and others) *~ +*.err +*.out + diff --git a/utils/slither_format/tests/test_data/naming_convention_state_variable.sol b/utils/slither_format/tests/test_data/naming_convention_state_variable.sol index 449fcb2db..2e7239f71 100644 --- a/utils/slither_format/tests/test_data/naming_convention_state_variable.sol +++ b/utils/slither_format/tests/test_data/naming_convention_state_variable.sol @@ -28,3 +28,10 @@ contract B { } } +contract C is B { + function foo() { + /* State variable uses - bad */ + uint i = number + Maxnum; + } +} + diff --git a/utils/slither_format/tests/test_data/naming_convention_state_variable_inheritance.sol b/utils/slither_format/tests/test_data/naming_convention_state_variable_inheritance.sol deleted file mode 100644 index 2e7239f71..000000000 --- a/utils/slither_format/tests/test_data/naming_convention_state_variable_inheritance.sol +++ /dev/null @@ -1,37 +0,0 @@ -pragma solidity ^0.4.24; - -contract A { - /* State variable declaration constant - good */ - uint constant NUMBER = 100; - /* State variable declaration private - good */ - uint private count = 100; - /* State variable declaration non-constant non-private - good */ - uint maxnum = 999; - - function foo() { - /* State variable uses - good */ - uint i = NUMBER + count + maxnum; - } -} - -contract B { - /* State variable declaration constant - bad */ - uint constant number = 100; - /* State variable declaration private - bad */ - uint private Count = 100; - /* State variable declaration non-constant non-private - good */ - uint Maxnum = 999; - function foo() { - /* State variable uses - bad */ - uint i = number + Count + Maxnum; - Count += i; - } -} - -contract C is B { - function foo() { - /* State variable uses - bad */ - uint i = number + Maxnum; - } -} - diff --git a/utils/slither_format/tests/test_naming_convention.py b/utils/slither_format/tests/test_naming_convention.py index 358282f66..67900b9b9 100644 --- a/utils/slither_format/tests/test_naming_convention.py +++ b/utils/slither_format/tests/test_naming_convention.py @@ -11,7 +11,6 @@ class TestNamingConvention(unittest.TestCase): testDataFile6 = "naming_convention_function.sol" testDataFile7 = "naming_convention_parameter.sol" testDataFile8 = "naming_convention_state_variable.sol" - testDataFile9 = "naming_convention_state_variable_inheritance.sol" testFilePath1 = testDataDir+testDataFile1 testFilePath2 = testDataDir+testDataFile2 testFilePath3 = testDataDir+testDataFile3 @@ -20,7 +19,6 @@ class TestNamingConvention(unittest.TestCase): testFilePath6 = testDataDir+testDataFile6 testFilePath7 = testDataDir+testDataFile7 testFilePath8 = testDataDir+testDataFile8 - testFilePath9 = testDataDir+testDataFile9 def setUp(self): outFD1 = open(self.testFilePath1+".out","w") @@ -79,13 +77,6 @@ class TestNamingConvention(unittest.TestCase): outFD8.close() errFD8.close() - outFD9 = open(self.testFilePath9+".out","w") - errFD9 = open(self.testFilePath9+".err","w") - p8 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose-test','--detect','naming-convention',self.testFilePath9], stdout=outFD9,stderr=errFD9) - p8.wait() - outFD9.close() - errFD9.close() - def tearDown(self): p1 = subprocess.Popen(['rm','-f',self.testFilePath1+'.out',self.testFilePath1+'.err',self.testFilePath1+'.format']) p1.wait() @@ -103,44 +94,6 @@ class TestNamingConvention(unittest.TestCase): p7.wait() p8 = subprocess.Popen(['rm','-f',self.testFilePath8+'.out',self.testFilePath8+'.err',self.testFilePath8+'.format']) p8.wait() - p9 = subprocess.Popen(['rm','-f',self.testFilePath9+'.out',self.testFilePath9+'.err',self.testFilePath9+'.format']) - p9.wait() - - def test_naming_convention_state_variable_inheritance(self): - outFD9 = open(self.testFilePath9+".out","r") - outFD9_lines = outFD9.readlines() - outFD9.close() - for i in range(len(outFD9_lines)): - outFD9_lines[i] = outFD9_lines[i].strip() - self.assertTrue(os.path.isfile(self.testFilePath9+".format"),"Patched .format file is not created?!") - self.assertEqual(outFD9_lines[0],"Number of Slither results: 3") - self.assertEqual(outFD9_lines[1],"Number of patches: 9") - self.assertEqual(outFD9_lines.count("Detector: naming-convention (state variable declaration)"), 3) - self.assertEqual(outFD9_lines.count("Detector: naming-convention (state variable uses)"), 6) - self.assertEqual(outFD9_lines.count("Old string: number"), 3) - self.assertEqual(outFD9_lines.count("New string: NUMBER"), 3) - self.assertEqual(outFD9_lines.count("Location start: 469"), 1) - self.assertEqual(outFD9_lines.count("Location end: 475"), 1) - self.assertEqual(outFD9_lines.count("Location start: 716"), 1) - self.assertEqual(outFD9_lines.count("Location end: 722"), 1) - self.assertEqual(outFD9_lines.count("Location start: 850"), 1) - self.assertEqual(outFD9_lines.count("Location end: 856"), 1) - self.assertEqual(outFD9_lines.count("Old string: Count"), 3) - self.assertEqual(outFD9_lines.count("New string: count"), 3) - self.assertEqual(outFD9_lines.count("Location start: 547"), 1) - self.assertEqual(outFD9_lines.count("Location end: 552"), 1) - self.assertEqual(outFD9_lines.count("Location start: 725"), 1) - self.assertEqual(outFD9_lines.count("Location end: 730"), 1) - self.assertEqual(outFD9_lines.count("Location start: 745"), 1) - self.assertEqual(outFD9_lines.count("Location end: 750"), 1) - self.assertEqual(outFD9_lines.count("Old string: Maxnum"), 3) - self.assertEqual(outFD9_lines.count("New string: maxnum"), 3) - self.assertEqual(outFD9_lines.count("Location start: 634"), 1) - self.assertEqual(outFD9_lines.count("Location end: 640"), 1) - self.assertEqual(outFD9_lines.count("Location start: 733"), 1) - self.assertEqual(outFD9_lines.count("Location end: 739"), 1) - self.assertEqual(outFD9_lines.count("Location start: 859"), 1) - self.assertEqual(outFD9_lines.count("Location end: 865"), 1) def test_naming_convention_contract(self): outFD1 = open(self.testFilePath1+".out","r") @@ -406,15 +359,17 @@ class TestNamingConvention(unittest.TestCase): outFD8_lines[i] = outFD8_lines[i].strip() self.assertTrue(os.path.isfile(self.testFilePath8+".format"),"Patched .format file is not created?!") self.assertEqual(outFD8_lines[0],"Number of Slither results: 3") - self.assertEqual(outFD8_lines[1],"Number of patches: 7") + self.assertEqual(outFD8_lines[1],"Number of patches: 9") self.assertEqual(outFD8_lines.count("Detector: naming-convention (state variable declaration)"), 3) - self.assertEqual(outFD8_lines.count("Detector: naming-convention (state variable uses)"), 4) - self.assertEqual(outFD8_lines.count("Old string: number"), 2) - self.assertEqual(outFD8_lines.count("New string: NUMBER"), 2) + self.assertEqual(outFD8_lines.count("Detector: naming-convention (state variable uses)"), 6) + self.assertEqual(outFD8_lines.count("Old string: number"), 3) + self.assertEqual(outFD8_lines.count("New string: NUMBER"), 3) self.assertEqual(outFD8_lines.count("Location start: 469"), 1) self.assertEqual(outFD8_lines.count("Location end: 475"), 1) self.assertEqual(outFD8_lines.count("Location start: 716"), 1) self.assertEqual(outFD8_lines.count("Location end: 722"), 1) + self.assertEqual(outFD8_lines.count("Location start: 850"), 1) + self.assertEqual(outFD8_lines.count("Location end: 856"), 1) self.assertEqual(outFD8_lines.count("Old string: Count"), 3) self.assertEqual(outFD8_lines.count("New string: count"), 3) self.assertEqual(outFD8_lines.count("Location start: 547"), 1) @@ -423,12 +378,14 @@ class TestNamingConvention(unittest.TestCase): self.assertEqual(outFD8_lines.count("Location end: 730"), 1) self.assertEqual(outFD8_lines.count("Location start: 745"), 1) self.assertEqual(outFD8_lines.count("Location end: 750"), 1) - self.assertEqual(outFD8_lines.count("Old string: Maxnum"), 2) - self.assertEqual(outFD8_lines.count("New string: maxnum"), 2) + self.assertEqual(outFD8_lines.count("Old string: Maxnum"), 3) + self.assertEqual(outFD8_lines.count("New string: maxnum"), 3) self.assertEqual(outFD8_lines.count("Location start: 634"), 1) self.assertEqual(outFD8_lines.count("Location end: 640"), 1) self.assertEqual(outFD8_lines.count("Location start: 733"), 1) self.assertEqual(outFD8_lines.count("Location end: 739"), 1) + self.assertEqual(outFD8_lines.count("Location start: 859"), 1) + self.assertEqual(outFD8_lines.count("Location end: 865"), 1) if __name__ == '__main__': unittest.main() From 54f3f26e8a2afa23deaeed97385f47b565d865ec Mon Sep 17 00:00:00 2001 From: rajeevgopalakrishna Date: Thu, 16 May 2019 17:53:54 +0530 Subject: [PATCH 021/223] Adds support for inheritance in naming-convention of structure variables. --- .../format_naming_convention.py | 60 ++++++++++--------- .../test_data/naming_convention_structure.sol | 7 +++ .../tests/test_naming_convention.py | 16 +++-- 3 files changed, 49 insertions(+), 34 deletions(-) diff --git a/utils/slither_format/format_naming_convention.py b/utils/slither_format/format_naming_convention.py index 7ebbd3b59..4fcb65027 100644 --- a/utils/slither_format/format_naming_convention.py +++ b/utils/slither_format/format_naming_convention.py @@ -544,38 +544,42 @@ t']:(node.source_mapping['start']+node.source_mapping['length'])].split('=')[0]) @staticmethod def create_patch_struct_uses(slither, patches, name, contract_name, in_file): for contract in slither.contracts: - in_file_str = slither.source_code[in_file] - # Check state variables of struct type - # To-do: Deep-check aggregate types (struct and mapping) - svs = contract.variables - for sv in svs: - if (str(sv.type) == contract_name + "." + name): - old_str_of_interest = in_file_str[sv.source_mapping['start']:(sv.source_mapping['start']+sv.source_mapping['length'])] - (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(),old_str_of_interest, 1) - patch = { - "detector" : "naming-convention (struct use)", - "start" : sv.source_mapping['start'], - "end" : sv.source_mapping['start'] + sv.source_mapping['length'], - "old_string" : old_str_of_interest, - "new_string" : new_str_of_interest - } - if not patch in patches[in_file]: - patches[in_file].append(patch) - # Check function+modifier locals+parameters+returns - # To-do: Deep-check aggregate types (struct and mapping) - fms = contract.functions + contract.modifiers - for fm in fms: - for v in fm.variables: - if (str(v.type) == contract_name + "." + name): - old_str_of_interest = in_file_str[v.source_mapping['start']:(v.source_mapping['start']+v.source_mapping['length'])] + if (contract.name == contract_name): + target_contract = contract + for contract in slither.contracts: + if (contract == target_contract or (contract in target_contract.derived_contracts)): + in_file_str = slither.source_code[in_file] + # Check state variables of struct type + # To-do: Deep-check aggregate types (struct and mapping) + svs = contract.variables + for sv in svs: + if (str(sv.type) == contract_name + "." + name): + old_str_of_interest = in_file_str[sv.source_mapping['start']:(sv.source_mapping['start']+sv.source_mapping['length'])] (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(),old_str_of_interest, 1) patch = { "detector" : "naming-convention (struct use)", - "start" : v.source_mapping['start'], - "end" : v.source_mapping['start'] + v.source_mapping['length'], + "start" : sv.source_mapping['start'], + "end" : sv.source_mapping['start'] + sv.source_mapping['length'], "old_string" : old_str_of_interest, "new_string" : new_str_of_interest } - if not patch in patches[in_file]: + if not patch in patches[in_file]: patches[in_file].append(patch) - # To-do: Check any other place/way where struct type is used (e.g. typecast) + # Check function+modifier locals+parameters+returns + # To-do: Deep-check aggregate types (struct and mapping) + fms = contract.functions + contract.modifiers + for fm in fms: + for v in fm.variables: + if (str(v.type) == contract_name + "." + name): + old_str_of_interest = in_file_str[v.source_mapping['start']:(v.source_mapping['start']+v.source_mapping['length'])] + (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(),old_str_of_interest, 1) + patch = { + "detector" : "naming-convention (struct use)", + "start" : v.source_mapping['start'], + "end" : v.source_mapping['start'] + v.source_mapping['length'], + "old_string" : old_str_of_interest, + "new_string" : new_str_of_interest + } + if not patch in patches[in_file]: + patches[in_file].append(patch) + # To-do: Check any other place/way where struct type is used (e.g. typecast) diff --git a/utils/slither_format/tests/test_data/naming_convention_structure.sol b/utils/slither_format/tests/test_data/naming_convention_structure.sol index 79886ba91..2d65af314 100644 --- a/utils/slither_format/tests/test_data/naming_convention_structure.sol +++ b/utils/slither_format/tests/test_data/naming_convention_structure.sol @@ -49,3 +49,10 @@ contract C { } } +contract D is C { + /* struct as parameter and return value - bad */ + function foo(s sA) returns (s) { + s1.i = sA.i; + return (s1); + } +} diff --git a/utils/slither_format/tests/test_naming_convention.py b/utils/slither_format/tests/test_naming_convention.py index 67900b9b9..4e3ab50d6 100644 --- a/utils/slither_format/tests/test_naming_convention.py +++ b/utils/slither_format/tests/test_naming_convention.py @@ -185,9 +185,9 @@ class TestNamingConvention(unittest.TestCase): outFD3_lines[i] = outFD3_lines[i].strip() self.assertTrue(os.path.isfile(self.testFilePath3+".format"),"Patched .format file is not created?!") self.assertEqual(outFD3_lines[0],"Number of Slither results: 2") - self.assertEqual(outFD3_lines[1],"Number of patches: 6") + self.assertEqual(outFD3_lines[1],"Number of patches: 8") self.assertEqual(outFD3_lines.count("Detector: naming-convention (struct definition)"), 2) - self.assertEqual(outFD3_lines.count("Detector: naming-convention (struct use)"), 4) + self.assertEqual(outFD3_lines.count("Detector: naming-convention (struct use)"), 6) self.assertEqual(outFD3_lines.count("Old string: struct s { uint i; }"), 2) self.assertEqual(outFD3_lines.count("New string: struct S { uint i; }"), 2) self.assertEqual(outFD3_lines.count("Location start: 108"), 1) @@ -200,14 +200,18 @@ class TestNamingConvention(unittest.TestCase): self.assertEqual(outFD3_lines.count("Location end: 175"), 1) self.assertEqual(outFD3_lines.count("Location start: 497"), 1) self.assertEqual(outFD3_lines.count("Location end: 501"), 1) - self.assertEqual(outFD3_lines.count("Old string: s sA"), 1) - self.assertEqual(outFD3_lines.count("New string: S sA"), 1) + self.assertEqual(outFD3_lines.count("Old string: s sA"), 2) + self.assertEqual(outFD3_lines.count("New string: S sA"), 2) self.assertEqual(outFD3_lines.count("Location start: 570"), 1) self.assertEqual(outFD3_lines.count("Location end: 574"), 1) - self.assertEqual(outFD3_lines.count("Old string: s"), 1) - self.assertEqual(outFD3_lines.count("New string: S"), 1) + self.assertEqual(outFD3_lines.count("Location start: 715"), 1) + self.assertEqual(outFD3_lines.count("Location end: 719"), 1) + self.assertEqual(outFD3_lines.count("Old string: s"), 2) + self.assertEqual(outFD3_lines.count("New string: S"), 2) self.assertEqual(outFD3_lines.count("Location start: 585"), 1) self.assertEqual(outFD3_lines.count("Location end: 586"), 1) + self.assertEqual(outFD3_lines.count("Location start: 730"), 1) + self.assertEqual(outFD3_lines.count("Location end: 731"), 1) def test_naming_convention_enum(self): outFD4 = open(self.testFilePath4+".out","r") From be84d6618a9e42db8310910398bfb168f66704d7 Mon Sep 17 00:00:00 2001 From: rajeevgopalakrishna Date: Thu, 16 May 2019 18:10:11 +0530 Subject: [PATCH 022/223] Adds support for inheritance in naming-convention of enums. --- .../format_naming_convention.py | 5 ++++- .../test_data/naming_convention_enum.sol | 7 ++++++ .../tests/test_naming_convention.py | 22 ++++++++++++++----- 3 files changed, 27 insertions(+), 7 deletions(-) diff --git a/utils/slither_format/format_naming_convention.py b/utils/slither_format/format_naming_convention.py index 4fcb65027..089933553 100644 --- a/utils/slither_format/format_naming_convention.py +++ b/utils/slither_format/format_naming_convention.py @@ -456,7 +456,10 @@ class FormatNamingConvention: @staticmethod def create_patch_enum_uses(slither, patches, name, contract_name, in_file): for contract in slither.contracts: - if contract.name == contract_name: + if (contract.name == contract_name): + target_contract = contract + for contract in slither.contracts: + if (contract == target_contract or (contract in target_contract.derived_contracts)): in_file_str = slither.source_code[in_file] # Check state variable declarations of enum type # To-do: Deep-check aggregate types (struct and mapping) diff --git a/utils/slither_format/tests/test_data/naming_convention_enum.sol b/utils/slither_format/tests/test_data/naming_convention_enum.sol index 386be0c3d..2f4f37904 100644 --- a/utils/slither_format/tests/test_data/naming_convention_enum.sol +++ b/utils/slither_format/tests/test_data/naming_convention_enum.sol @@ -44,3 +44,10 @@ contract C { } } +contract D is C { + /* enum as parameter and return value - bad */ + function foo(e eA) returns (e) { + e e2 = eA; + return (e2); + } +} diff --git a/utils/slither_format/tests/test_naming_convention.py b/utils/slither_format/tests/test_naming_convention.py index 4e3ab50d6..ee6639e1e 100644 --- a/utils/slither_format/tests/test_naming_convention.py +++ b/utils/slither_format/tests/test_naming_convention.py @@ -221,9 +221,9 @@ class TestNamingConvention(unittest.TestCase): outFD4_lines[i] = outFD4_lines[i].strip() self.assertTrue(os.path.isfile(self.testFilePath4+".format"),"Patched .format file is not created?!") self.assertEqual(outFD4_lines[0],"Number of Slither results: 2") - self.assertEqual(outFD4_lines[1],"Number of patches: 8") + self.assertEqual(outFD4_lines[1],"Number of patches: 11") self.assertEqual(outFD4_lines.count("Detector: naming-convention (enum definition)"), 2) - self.assertEqual(outFD4_lines.count("Detector: naming-convention (enum use)"), 6) + self.assertEqual(outFD4_lines.count("Detector: naming-convention (enum use)"), 9) self.assertEqual(outFD4_lines.count("Old string: enum e {ONE, TWO}"), 2) self.assertEqual(outFD4_lines.count("New string: enum E {ONE, TWO}"), 2) self.assertEqual(outFD4_lines.count("Location start: 73"), 1) @@ -236,18 +236,28 @@ class TestNamingConvention(unittest.TestCase): self.assertEqual(outFD4_lines.count("Location end: 129"), 1) self.assertEqual(outFD4_lines.count("Location start: 478"), 1) self.assertEqual(outFD4_lines.count("Location end: 482"), 1) - self.assertEqual(outFD4_lines.count("Old string: e eA"), 1) - self.assertEqual(outFD4_lines.count("New string: E eA"), 1) + self.assertEqual(outFD4_lines.count("Old string: e eA"), 2) + self.assertEqual(outFD4_lines.count("New string: E eA"), 2) self.assertEqual(outFD4_lines.count("Location start: 549"), 1) self.assertEqual(outFD4_lines.count("Location end: 553"), 1) - self.assertEqual(outFD4_lines.count("Old string: e e2 = eA"), 1) - self.assertEqual(outFD4_lines.count("New string: E e2 = eA"), 1) + self.assertEqual(outFD4_lines.count("Location start: 690"), 1) + self.assertEqual(outFD4_lines.count("Location end: 694"), 1) + self.assertEqual(outFD4_lines.count("Old string: e e2 = eA"), 2) + self.assertEqual(outFD4_lines.count("New string: E e2 = eA"), 2) self.assertEqual(outFD4_lines.count("Location start: 573"), 1) self.assertEqual(outFD4_lines.count("Location end: 582"), 1) + self.assertEqual(outFD4_lines.count("Location start: 714"), 1) + self.assertEqual(outFD4_lines.count("Location end: 723"), 1) self.assertEqual(outFD4_lines.count("Old string: e.ONE"), 1) self.assertEqual(outFD4_lines.count("New string: E.ONE"), 1) self.assertEqual(outFD4_lines.count("Location start: 186"), 1) self.assertEqual(outFD4_lines.count("Location end: 192"), 1) + self.assertEqual(outFD4_lines.count("Old string: e"), 2) + self.assertEqual(outFD4_lines.count("New string: E"), 2) + self.assertEqual(outFD4_lines.count("Location start: 564"), 1) + self.assertEqual(outFD4_lines.count("Location end: 565"), 1) + self.assertEqual(outFD4_lines.count("Location start: 705"), 1) + self.assertEqual(outFD4_lines.count("Location end: 706"), 1) def test_naming_convention_event(self): outFD5 = open(self.testFilePath5+".out","r") From da8f14c84b5f2dda70ab197e9c1d438a54c0b33a Mon Sep 17 00:00:00 2001 From: rajeevgopalakrishna Date: Thu, 16 May 2019 18:20:01 +0530 Subject: [PATCH 023/223] Adds support for inheritance in naming-convention of event calls. --- utils/slither_format/format_naming_convention.py | 3 +++ .../tests/test_data/naming_convention_event.sol | 6 ++++++ utils/slither_format/tests/test_naming_convention.py | 10 ++++++---- 3 files changed, 15 insertions(+), 4 deletions(-) diff --git a/utils/slither_format/format_naming_convention.py b/utils/slither_format/format_naming_convention.py index 089933553..d5187e7a1 100644 --- a/utils/slither_format/format_naming_convention.py +++ b/utils/slither_format/format_naming_convention.py @@ -276,6 +276,9 @@ class FormatNamingConvention: event_name = name.split('(')[0] for contract in slither.contracts: if (contract.name == contract_name): + target_contract = contract + for contract in slither.contracts: + if (contract == target_contract or (contract in target_contract.derived_contracts)): for function in contract.functions: for node in function.nodes: for call in node.internal_calls_as_expressions: diff --git a/utils/slither_format/tests/test_data/naming_convention_event.sol b/utils/slither_format/tests/test_data/naming_convention_event.sol index 9616bb634..f53967043 100644 --- a/utils/slither_format/tests/test_data/naming_convention_event.sol +++ b/utils/slither_format/tests/test_data/naming_convention_event.sol @@ -32,3 +32,9 @@ contract Three { } +contract Four is Three { + function foo(uint i) { + /* event call with emit - bad */ + emit e(i); + } +} diff --git a/utils/slither_format/tests/test_naming_convention.py b/utils/slither_format/tests/test_naming_convention.py index ee6639e1e..b06a3a1b1 100644 --- a/utils/slither_format/tests/test_naming_convention.py +++ b/utils/slither_format/tests/test_naming_convention.py @@ -267,21 +267,23 @@ class TestNamingConvention(unittest.TestCase): outFD5_lines[i] = outFD5_lines[i].strip() self.assertTrue(os.path.isfile(self.testFilePath5+".format"),"Patched .format file is not created?!") self.assertEqual(outFD5_lines[0],"Number of Slither results: 2") - self.assertEqual(outFD5_lines[1],"Number of patches: 4") + self.assertEqual(outFD5_lines[1],"Number of patches: 5") self.assertEqual(outFD5_lines.count("Detector: naming-convention (event definition)"), 2) - self.assertEqual(outFD5_lines.count("Detector: naming-convention (event calls)"), 2) + self.assertEqual(outFD5_lines.count("Detector: naming-convention (event calls)"), 3) self.assertEqual(outFD5_lines.count("Old string: event e(uint);"), 2) self.assertEqual(outFD5_lines.count("New string: event E(uint);"), 2) self.assertEqual(outFD5_lines.count("Location start: 75"), 1) self.assertEqual(outFD5_lines.count("Location end: 89"), 1) self.assertEqual(outFD5_lines.count("Location start: 148"), 1) self.assertEqual(outFD5_lines.count("Location end: 152"), 1) - self.assertEqual(outFD5_lines.count("Old string: e(i)"), 2) - self.assertEqual(outFD5_lines.count("New string: E(i)"), 2) + self.assertEqual(outFD5_lines.count("Old string: e(i)"), 3) + self.assertEqual(outFD5_lines.count("New string: E(i)"), 3) self.assertEqual(outFD5_lines.count("Location start: 148"), 1) self.assertEqual(outFD5_lines.count("Location end: 152"), 1) self.assertEqual(outFD5_lines.count("Location start: 438"), 1) self.assertEqual(outFD5_lines.count("Location end: 442"), 1) + self.assertEqual(outFD5_lines.count("Location start: 550"), 1) + self.assertEqual(outFD5_lines.count("Location end: 554"), 1) def test_naming_convention_function(self): outFD6 = open(self.testFilePath6+".out","r") From 2e930765280cba818b37acc5bc9890551cb2e5c2 Mon Sep 17 00:00:00 2001 From: rajeevgopalakrishna Date: Thu, 16 May 2019 18:34:38 +0530 Subject: [PATCH 024/223] Adds support for inheritance in naming-convention of modifier uses. --- utils/slither_format/format_naming_convention.py | 5 ++++- .../tests/test_data/naming_convention_modifier.sol | 6 ++++++ utils/slither_format/tests/test_naming_convention.py | 10 ++++++---- 3 files changed, 16 insertions(+), 5 deletions(-) diff --git a/utils/slither_format/format_naming_convention.py b/utils/slither_format/format_naming_convention.py index d5187e7a1..2ab043e72 100644 --- a/utils/slither_format/format_naming_convention.py +++ b/utils/slither_format/format_naming_convention.py @@ -163,7 +163,10 @@ class FormatNamingConvention: @staticmethod def create_patch_modifier_uses(slither, patches, name, contract_name, in_file): for contract in slither.contracts: - if contract.name == contract_name: + if (contract.name == contract_name): + target_contract = contract + for contract in slither.contracts: + if (contract == target_contract or (contract in target_contract.derived_contracts)): for function in contract.functions: for m in function.modifiers: if (m.name == name): diff --git a/utils/slither_format/tests/test_data/naming_convention_modifier.sol b/utils/slither_format/tests/test_data/naming_convention_modifier.sol index 1e658c9a8..3ae9efa17 100644 --- a/utils/slither_format/tests/test_data/naming_convention_modifier.sol +++ b/utils/slither_format/tests/test_data/naming_convention_modifier.sol @@ -45,3 +45,9 @@ contract C { } +contract D is C { + /* modifier uses - good and bad */ + function foo() one Two returns (uint) { + } +} + diff --git a/utils/slither_format/tests/test_naming_convention.py b/utils/slither_format/tests/test_naming_convention.py index b06a3a1b1..178676dca 100644 --- a/utils/slither_format/tests/test_naming_convention.py +++ b/utils/slither_format/tests/test_naming_convention.py @@ -157,9 +157,9 @@ class TestNamingConvention(unittest.TestCase): outFD2_lines[i] = outFD2_lines[i].strip() self.assertTrue(os.path.isfile(self.testFilePath2+".format"),"Patched .format file is not created?!") self.assertEqual(outFD2_lines[0],"Number of Slither results: 2") - self.assertEqual(outFD2_lines[1],"Number of patches: 4") + self.assertEqual(outFD2_lines[1],"Number of patches: 5") self.assertEqual(outFD2_lines.count("Detector: naming-convention (modifier definition)"), 2) - self.assertEqual(outFD2_lines.count("Detector: naming-convention (modifier uses)"), 2) + self.assertEqual(outFD2_lines.count("Detector: naming-convention (modifier uses)"), 3) self.assertEqual(outFD2_lines.count("Old string: modifier One"), 1) self.assertEqual(outFD2_lines.count("New string: modifier one"), 1) self.assertEqual(outFD2_lines.count("Location start: 215"), 1) @@ -172,10 +172,12 @@ class TestNamingConvention(unittest.TestCase): self.assertEqual(outFD2_lines.count("New string: modifier two"), 1) self.assertEqual(outFD2_lines.count("Location start: 423"), 1) self.assertEqual(outFD2_lines.count("Location end: 435"), 1) - self.assertEqual(outFD2_lines.count("Old string: () one Two returns"), 1) - self.assertEqual(outFD2_lines.count("New string: () one two returns"), 1) + self.assertEqual(outFD2_lines.count("Old string: () one Two returns"), 2) + self.assertEqual(outFD2_lines.count("New string: () one two returns"), 2) self.assertEqual(outFD2_lines.count("Location start: 503"), 1) self.assertEqual(outFD2_lines.count("Location end: 522"), 1) + self.assertEqual(outFD2_lines.count("Location start: 718"), 1) + self.assertEqual(outFD2_lines.count("Location end: 737"), 1) def test_naming_convention_structure(self): outFD3 = open(self.testFilePath3+".out","r") From 128f1a3ced9ea5e87423a2c1fc9e771cfe90b596 Mon Sep 17 00:00:00 2001 From: rajeevgopalakrishna Date: Fri, 17 May 2019 10:14:33 +0530 Subject: [PATCH 025/223] Fixes uninitialised variable bugh! Manifests when patch count is zero. --- utils/slither_format/slither_format.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/utils/slither_format/slither_format.py b/utils/slither_format/slither_format.py index 86bdf0660..df68e0e33 100644 --- a/utils/slither_format/slither_format.py +++ b/utils/slither_format/slither_format.py @@ -93,7 +93,8 @@ def apply_patches(slither, patches): else: out_file_str += in_file_str[:int(patches[file][i]['start'])] out_file_str += patches[file][i]['new_string'] - out_file_str += in_file_str[int(patches[file][i]['end']):] + if (i == (len(patches[file]) - 1)): + out_file_str += in_file_str[int(patches[file][i]['end']):] out_file = open(_in_file+".format",'w') out_file.write(out_file_str) out_file.close() From ebb5502ac9ad58d6b15467707edf8b0d3bdae48a Mon Sep 17 00:00:00 2001 From: rajeevgopalakrishna Date: Fri, 17 May 2019 18:19:17 +0530 Subject: [PATCH 026/223] Adds support for crytic_compile cryticparser. --- utils/slither_format/__main__.py | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-) diff --git a/utils/slither_format/__main__.py b/utils/slither_format/__main__.py index 0c4292618..feaf39ac8 100644 --- a/utils/slither_format/__main__.py +++ b/utils/slither_format/__main__.py @@ -1,9 +1,10 @@ -import os +import os, sys import argparse from slither import Slither from slither.utils.colors import red import logging from .slither_format import slither_format +from crytic_compile import cryticparser logging.basicConfig() logging.getLogger("Slither").setLevel(logging.INFO) @@ -27,7 +28,6 @@ def parse_args(): usage='slither_format filename') parser.add_argument('filename', help='The filename of the contract or truffle directory to analyze.') - parser.add_argument('--solc', help='solc path', default='solc') parser.add_argument('--verbose-test', '-v', help='verbose mode output for testing',action='store_true',default=False) parser.add_argument('--verbose-json', '-j', help='verbose json output',action='store_true',default=False) @@ -39,6 +39,13 @@ def parse_args(): action='store', dest='detectors_to_run', default='all') + + cryticparser.init(parser) + + if len(sys.argv) == 1: + parser.print_help(sys.stderr) + sys.exit(1) + return parser.parse_args() @@ -51,7 +58,7 @@ def main(): args = parse_args() # Perform slither analysis on the given filename - slither = Slither(args.filename, is_truffle=os.path.isdir(args.filename), solc=args.solc, disable_solc_warnings=True) + slither = Slither(args.filename, **vars(args)) # Format the input files based on slither analysis slither_format(args, slither) From 91ce3b701e8cf07c4ef52564676275202e69918f Mon Sep 17 00:00:00 2001 From: rajeevgopalakrishna Date: Mon, 20 May 2019 12:03:50 +0530 Subject: [PATCH 027/223] Adds debug prints. Adds CryptoKitty Core test which fails because of incorrect source mappings? --- .../format_naming_convention.py | 29 +- ...ead5deae237070f9587f8e7a266d_KittyCore.sol | 2009 +++++++++++++++++ 2 files changed, 2034 insertions(+), 4 deletions(-) create mode 100644 utils/slither_format/tests/real_world/0x06012c8cf97bead5deae237070f9587f8e7a266d_KittyCore.sol diff --git a/utils/slither_format/format_naming_convention.py b/utils/slither_format/format_naming_convention.py index 2ab043e72..694ae3f72 100644 --- a/utils/slither_format/format_naming_convention.py +++ b/utils/slither_format/format_naming_convention.py @@ -68,6 +68,8 @@ class FormatNamingConvention: patches[in_file].append(patch) else: print("Error: Could not find contract?!") + print("old_str_of_interest: " + old_str_of_interest) + print("Contract : " + name) sys.exit(-1) @staticmethod @@ -129,6 +131,8 @@ class FormatNamingConvention: patches[in_file].append(patch) else: print("Error: Could not find new object?!") + print("old_str_of_interest: " + old_str_of_interest) + print("Contract : " + name) sys.exit(-1) else: @@ -158,6 +162,8 @@ class FormatNamingConvention: patches[in_file].append(patch) else: print("Error: Could not find modifier?!") + print("old_str_of_interest: " + old_str_of_interest) + print("Modifier: " + name + " in Contract : " + contract_name) sys.exit(-1) @staticmethod @@ -185,6 +191,8 @@ class FormatNamingConvention: patches[in_file].append(patch) else: print("Error: Could not find modifier name?!") + print("old_str_of_interest: " + old_str_of_interest) + print("Modifier: " + name + " in Contract : " + contract_name) sys.exit(-1) @staticmethod @@ -210,6 +218,8 @@ class FormatNamingConvention: patches[in_file].append(patch) else: print("Error: Could not find function?!") + print("old_str_of_interest: " + old_str_of_interest) + print("Function: " + name + " in Contract : " + contract_name) sys.exit(-1) @staticmethod @@ -272,6 +282,8 @@ class FormatNamingConvention: patches[in_file].append(patch) else: print("Error: Could not find event?!") + print("old_str_of_interest: " + old_str_of_interest) + print("Event: " + name + " in Contract : " + contract_name) sys.exit(-1) @staticmethod @@ -321,7 +333,9 @@ class FormatNamingConvention: if not patch in patches[in_file]: patches[in_file].append(patch) else: - print("Error: Could not find parameter?!") + print("Error: Could not find parameter declaration?!") + print("old_str_of_interest: " + old_str_of_interest) + print("Parameter: " + name + " of Function: " + function_name + " in Contract : " + contract_name) sys.exit(-1) @staticmethod @@ -353,8 +367,9 @@ class FormatNamingConvention: if not patch in patches[in_file]: patches[in_file].append(patch) else: - print("Error: Could not find parameter?!") - sys.exit(-1) + print("Error: Could not find parameter use?!") + print("old_str_of_interest: " + old_str_of_interest) + print("Parameter: " + name + " of Function: " + function_name + " in Contract : " + contract_name) # Process function parameters passed to modifiers for modifier in function._expression_modifiers: for arg in modifier.arguments: @@ -376,7 +391,9 @@ class FormatNamingConvention: if not patch in patches[in_file]: patches[in_file].append(patch) else: - print("Error: Could not find parameter?!") + print("Error: Could not find parameter use in modifier?!") + print("old_str_of_interest: " + old_str_of_interest) + print("Parameter: " + name + " of Function: " + function_name + " in Contract : " + contract_name) sys.exit(-1) @staticmethod @@ -457,6 +474,8 @@ class FormatNamingConvention: patches[in_file].append(patch) else: print("Error: Could not find enum?!") + print("old_str_of_interest: " + old_str_of_interest) + print("Enum: " + name + " in Contract : " + contract_name) sys.exit(-1) @staticmethod @@ -524,6 +543,7 @@ t']:(node.source_mapping['start']+node.source_mapping['length'])].split('=')[0]) patches[in_file].append(patch) else: print("Error: Could not find new object?!") + print("Enum: " + name + " in Contract : " + contract_name) sys.exit(-1) # To-do: Check any other place/way where enum type is used @@ -548,6 +568,7 @@ t']:(node.source_mapping['start']+node.source_mapping['length'])].split('=')[0]) patches[in_file].append(patch) else: print("Error: Could not find struct?!") + print("Struct: " + name + " in Contract : " + contract_name) sys.exit(-1) @staticmethod diff --git a/utils/slither_format/tests/real_world/0x06012c8cf97bead5deae237070f9587f8e7a266d_KittyCore.sol b/utils/slither_format/tests/real_world/0x06012c8cf97bead5deae237070f9587f8e7a266d_KittyCore.sol new file mode 100644 index 000000000..99868cfac --- /dev/null +++ b/utils/slither_format/tests/real_world/0x06012c8cf97bead5deae237070f9587f8e7a266d_KittyCore.sol @@ -0,0 +1,2009 @@ +pragma solidity ^0.4.11; + + +/** + * @title Ownable + * @dev The Ownable contract has an owner address, and provides basic authorization control + * functions, this simplifies the implementation of "user permissions". + */ +contract Ownable { + address public owner; + + + /** + * @dev The Ownable constructor sets the original `owner` of the contract to the sender + * account. + */ + function Ownable() { + owner = msg.sender; + } + + + /** + * @dev Throws if called by any account other than the owner. + */ + modifier onlyOwner() { + require(msg.sender == owner); + _; + } + + + /** + * @dev Allows the current owner to transfer control of the contract to a newOwner. + * @param newOwner The address to transfer ownership to. + */ + function transferOwnership(address newOwner) onlyOwner { + if (newOwner != address(0)) { + owner = newOwner; + } + } + +} + + + +/// @title Interface for contracts conforming to ERC-721: Non-Fungible Tokens +/// @author Dieter Shirley <[email protected]> (https://github.com/dete) +contract ERC721 { + // Required methods + function totalSupply() public view returns (uint256 total); + function balanceOf(address _owner) public view returns (uint256 balance); + function ownerOf(uint256 _tokenId) external view returns (address owner); + function approve(address _to, uint256 _tokenId) external; + function transfer(address _to, uint256 _tokenId) external; + function transferFrom(address _from, address _to, uint256 _tokenId) external; + + // Events + event Transfer(address from, address to, uint256 tokenId); + event Approval(address owner, address approved, uint256 tokenId); + + // Optional + // function name() public view returns (string name); + // function symbol() public view returns (string symbol); + // function tokensOfOwner(address _owner) external view returns (uint256[] tokenIds); + // function tokenMetadata(uint256 _tokenId, string _preferredTransport) public view returns (string infoUrl); + + // ERC-165 Compatibility (https://github.com/ethereum/EIPs/issues/165) + function supportsInterface(bytes4 _interfaceID) external view returns (bool); +} + + +// // Auction wrapper functions + + +// Auction wrapper functions + + + + + + + +/// @title SEKRETOOOO +contract GeneScienceInterface { + /// @dev simply a boolean to indicate this is the contract we expect to be + function isGeneScience() public pure returns (bool); + + /// @dev given genes of kitten 1 & 2, return a genetic combination - may have a random factor + /// @param genes1 genes of mom + /// @param genes2 genes of sire + /// @return the genes that are supposed to be passed down the child + function mixGenes(uint256 genes1, uint256 genes2, uint256 targetBlock) public returns (uint256); +} + + + + + + + +/// @title A facet of KittyCore that manages special access privileges. +/// @author Axiom Zen (https://www.axiomzen.co) +/// @dev See the KittyCore contract documentation to understand how the various contract facets are arranged. +contract KittyAccessControl { + // This facet controls access control for CryptoKitties. There are four roles managed here: + // + // - The CEO: The CEO can reassign other roles and change the addresses of our dependent smart + // contracts. It is also the only role that can unpause the smart contract. It is initially + // set to the address that created the smart contract in the KittyCore constructor. + // + // - The CFO: The CFO can withdraw funds from KittyCore and its auction contracts. + // + // - The COO: The COO can release gen0 kitties to auction, and mint promo cats. + // + // It should be noted that these roles are distinct without overlap in their access abilities, the + // abilities listed for each role above are exhaustive. In particular, while the CEO can assign any + // address to any role, the CEO address itself doesn't have the ability to act in those roles. This + // restriction is intentional so that we aren't tempted to use the CEO address frequently out of + // convenience. The less we use an address, the less likely it is that we somehow compromise the + // account. + + /// @dev Emited when contract is upgraded - See README.md for updgrade plan + event ContractUpgrade(address newContract); + + // The addresses of the accounts (or contracts) that can execute actions within each roles. + address public ceoAddress; + address public cfoAddress; + address public cooAddress; + + // @dev Keeps track whether the contract is paused. When that is true, most actions are blocked + bool public paused = false; + + /// @dev Access modifier for CEO-only functionality + modifier onlyCEO() { + require(msg.sender == ceoAddress); + _; + } + + /// @dev Access modifier for CFO-only functionality + modifier onlyCFO() { + require(msg.sender == cfoAddress); + _; + } + + /// @dev Access modifier for COO-only functionality + modifier onlyCOO() { + require(msg.sender == cooAddress); + _; + } + + modifier onlyCLevel() { + require( + msg.sender == cooAddress || + msg.sender == ceoAddress || + msg.sender == cfoAddress + ); + _; + } + + /// @dev Assigns a new address to act as the CEO. Only available to the current CEO. + /// @param _newCEO The address of the new CEO + function setCEO(address _newCEO) external onlyCEO { + require(_newCEO != address(0)); + + ceoAddress = _newCEO; + } + + /// @dev Assigns a new address to act as the CFO. Only available to the current CEO. + /// @param _newCFO The address of the new CFO + function setCFO(address _newCFO) external onlyCEO { + require(_newCFO != address(0)); + + cfoAddress = _newCFO; + } + + /// @dev Assigns a new address to act as the COO. Only available to the current CEO. + /// @param _newCOO The address of the new COO + function setCOO(address _newCOO) external onlyCEO { + require(_newCOO != address(0)); + + cooAddress = _newCOO; + } + + /*** Pausable functionality adapted from OpenZeppelin ***/ + + /// @dev Modifier to allow actions only when the contract IS NOT paused + modifier whenNotPaused() { + require(!paused); + _; + } + + /// @dev Modifier to allow actions only when the contract IS paused + modifier whenPaused { + require(paused); + _; + } + + /// @dev Called by any "C-level" role to pause the contract. Used only when + /// a bug or exploit is detected and we need to limit damage. + function pause() external onlyCLevel whenNotPaused { + paused = true; + } + + /// @dev Unpauses the smart contract. Can only be called by the CEO, since + /// one reason we may pause the contract is when CFO or COO accounts are + /// compromised. + /// @notice This is public rather than external so it can be called by + /// derived contracts. + function unpause() public onlyCEO whenPaused { + // can't unpause if contract was upgraded + paused = false; + } +} + + + + +/// @title Base contract for CryptoKitties. Holds all common structs, events and base variables. +/// @author Axiom Zen (https://www.axiomzen.co) +/// @dev See the KittyCore contract documentation to understand how the various contract facets are arranged. +contract KittyBase is KittyAccessControl { + /*** EVENTS ***/ + + /// @dev The Birth event is fired whenever a new kitten comes into existence. This obviously + /// includes any time a cat is created through the giveBirth method, but it is also called + /// when a new gen0 cat is created. + event Birth(address owner, uint256 kittyId, uint256 matronId, uint256 sireId, uint256 genes); + + /// @dev Transfer event as defined in current draft of ERC721. Emitted every time a kitten + /// ownership is assigned, including births. + event Transfer(address from, address to, uint256 tokenId); + + /*** DATA TYPES ***/ + + /// @dev The main Kitty struct. Every cat in CryptoKitties is represented by a copy + /// of this structure, so great care was taken to ensure that it fits neatly into + /// exactly two 256-bit words. Note that the order of the members in this structure + /// is important because of the byte-packing rules used by Ethereum. + /// Ref: http://solidity.readthedocs.io/en/develop/miscellaneous.html + struct Kitty { + // The Kitty's genetic code is packed into these 256-bits, the format is + // sooper-sekret! A cat's genes never change. + uint256 genes; + + // The timestamp from the block when this cat came into existence. + uint64 birthTime; + + // The minimum timestamp after which this cat can engage in breeding + // activities again. This same timestamp is used for the pregnancy + // timer (for matrons) as well as the siring cooldown. + uint64 cooldownEndBlock; + + // The ID of the parents of this kitty, set to 0 for gen0 cats. + // Note that using 32-bit unsigned integers limits us to a "mere" + // 4 billion cats. This number might seem small until you realize + // that Ethereum currently has a limit of about 500 million + // transactions per year! So, this definitely won't be a problem + // for several years (even as Ethereum learns to scale). + uint32 matronId; + uint32 sireId; + + // Set to the ID of the sire cat for matrons that are pregnant, + // zero otherwise. A non-zero value here is how we know a cat + // is pregnant. Used to retrieve the genetic material for the new + // kitten when the birth transpires. + uint32 siringWithId; + + // Set to the index in the cooldown array (see below) that represents + // the current cooldown duration for this Kitty. This starts at zero + // for gen0 cats, and is initialized to floor(generation/2) for others. + // Incremented by one for each successful breeding action, regardless + // of whether this cat is acting as matron or sire. + uint16 cooldownIndex; + + // The "generation number" of this cat. Cats minted by the CK contract + // for sale are called "gen0" and have a generation number of 0. The + // generation number of all other cats is the larger of the two generation + // numbers of their parents, plus one. + // (i.e. max(matron.generation, sire.generation) + 1) + uint16 generation; + } + + /*** CONSTANTS ***/ + + /// @dev A lookup table indicating the cooldown duration after any successful + /// breeding action, called "pregnancy time" for matrons and "siring cooldown" + /// for sires. Designed such that the cooldown roughly doubles each time a cat + /// is bred, encouraging owners not to just keep breeding the same cat over + /// and over again. Caps out at one week (a cat can breed an unbounded number + /// of times, and the maximum cooldown is always seven days). + uint32[14] public cooldowns = [ + uint32(1 minutes), + uint32(2 minutes), + uint32(5 minutes), + uint32(10 minutes), + uint32(30 minutes), + uint32(1 hours), + uint32(2 hours), + uint32(4 hours), + uint32(8 hours), + uint32(16 hours), + uint32(1 days), + uint32(2 days), + uint32(4 days), + uint32(7 days) + ]; + + // An approximation of currently how many seconds are in between blocks. + uint256 public secondsPerBlock = 15; + + /*** STORAGE ***/ + + /// @dev An array containing the Kitty struct for all Kitties in existence. The ID + /// of each cat is actually an index into this array. Note that ID 0 is a negacat, + /// the unKitty, the mythical beast that is the parent of all gen0 cats. A bizarre + /// creature that is both matron and sire... to itself! Has an invalid genetic code. + /// In other words, cat ID 0 is invalid... ;-) + Kitty[] kitties; + + /// @dev A mapping from cat IDs to the address that owns them. All cats have + /// some valid owner address, even gen0 cats are created with a non-zero owner. + mapping (uint256 => address) public kittyIndexToOwner; + + // @dev A mapping from owner address to count of tokens that address owns. + // Used internally inside balanceOf() to resolve ownership count. + mapping (address => uint256) ownershipTokenCount; + + /// @dev A mapping from KittyIDs to an address that has been approved to call + /// transferFrom(). Each Kitty can only have one approved address for transfer + /// at any time. A zero value means no approval is outstanding. + mapping (uint256 => address) public kittyIndexToApproved; + + /// @dev A mapping from KittyIDs to an address that has been approved to use + /// this Kitty for siring via breedWith(). Each Kitty can only have one approved + /// address for siring at any time. A zero value means no approval is outstanding. + mapping (uint256 => address) public sireAllowedToAddress; + + /// @dev The address of the ClockAuction contract that handles sales of Kitties. This + /// same contract handles both peer-to-peer sales as well as the gen0 sales which are + /// initiated every 15 minutes. + SaleClockAuction public saleAuction; + + /// @dev The address of a custom ClockAuction subclassed contract that handles siring + /// auctions. Needs to be separate from saleAuction because the actions taken on success + /// after a sales and siring auction are quite different. + SiringClockAuction public siringAuction; + + /// @dev Assigns ownership of a specific Kitty to an address. + function _transfer(address _from, address _to, uint256 _tokenId) internal { + // Since the number of kittens is capped to 2^32 we can't overflow this + ownershipTokenCount[_to]++; + // transfer ownership + kittyIndexToOwner[_tokenId] = _to; + // When creating new kittens _from is 0x0, but we can't account that address. + if (_from != address(0)) { + ownershipTokenCount[_from]--; + // once the kitten is transferred also clear sire allowances + delete sireAllowedToAddress[_tokenId]; + // clear any previously approved ownership exchange + delete kittyIndexToApproved[_tokenId]; + } + // Emit the transfer event. + Transfer(_from, _to, _tokenId); + } + + /// @dev An internal method that creates a new kitty and stores it. This + /// method doesn't do any checking and should only be called when the + /// input data is known to be valid. Will generate both a Birth event + /// and a Transfer event. + /// @param _matronId The kitty ID of the matron of this cat (zero for gen0) + /// @param _sireId The kitty ID of the sire of this cat (zero for gen0) + /// @param _generation The generation number of this cat, must be computed by caller. + /// @param _genes The kitty's genetic code. + /// @param _owner The inital owner of this cat, must be non-zero (except for the unKitty, ID 0) + function _createKitty( + uint256 _matronId, + uint256 _sireId, + uint256 _generation, + uint256 _genes, + address _owner + ) + internal + returns (uint) + { + // These requires are not strictly necessary, our calling code should make + // sure that these conditions are never broken. However! _createKitty() is already + // an expensive call (for storage), and it doesn't hurt to be especially careful + // to ensure our data structures are always valid. + require(_matronId == uint256(uint32(_matronId))); + require(_sireId == uint256(uint32(_sireId))); + require(_generation == uint256(uint16(_generation))); + + // New kitty starts with the same cooldown as parent gen/2 + uint16 cooldownIndex = uint16(_generation / 2); + if (cooldownIndex > 13) { + cooldownIndex = 13; + } + + Kitty memory _kitty = Kitty({ + genes: _genes, + birthTime: uint64(now), + cooldownEndBlock: 0, + matronId: uint32(_matronId), + sireId: uint32(_sireId), + siringWithId: 0, + cooldownIndex: cooldownIndex, + generation: uint16(_generation) + }); + uint256 newKittenId = kitties.push(_kitty) - 1; + + // It's probably never going to happen, 4 billion cats is A LOT, but + // let's just be 100% sure we never let this happen. + require(newKittenId == uint256(uint32(newKittenId))); + + // emit the birth event + Birth( + _owner, + newKittenId, + uint256(_kitty.matronId), + uint256(_kitty.sireId), + _kitty.genes + ); + + // This will assign ownership, and also emit the Transfer event as + // per ERC721 draft + _transfer(0, _owner, newKittenId); + + return newKittenId; + } + + // Any C-level can fix how many seconds per blocks are currently observed. + function setSecondsPerBlock(uint256 secs) external onlyCLevel { + require(secs < cooldowns[0]); + secondsPerBlock = secs; + } +} + + + + + +/// @title The external contract that is responsible for generating metadata for the kitties, +/// it has one function that will return the data as bytes. +contract ERC721Metadata { + /// @dev Given a token Id, returns a byte array that is supposed to be converted into string. + function getMetadata(uint256 _tokenId, string) public view returns (bytes32[4] buffer, uint256 count) { + if (_tokenId == 1) { + buffer[0] = "Hello World! :D"; + count = 15; + } else if (_tokenId == 2) { + buffer[0] = "I would definitely choose a medi"; + buffer[1] = "um length string."; + count = 49; + } else if (_tokenId == 3) { + buffer[0] = "Lorem ipsum dolor sit amet, mi e"; + buffer[1] = "st accumsan dapibus augue lorem,"; + buffer[2] = " tristique vestibulum id, libero"; + buffer[3] = " suscipit varius sapien aliquam."; + count = 128; + } + } +} + + +/// @title The facet of the CryptoKitties core contract that manages ownership, ERC-721 (draft) compliant. +/// @author Axiom Zen (https://www.axiomzen.co) +/// @dev Ref: https://github.com/ethereum/EIPs/issues/721 +/// See the KittyCore contract documentation to understand how the various contract facets are arranged. +contract KittyOwnership is KittyBase, ERC721 { + + /// @notice Name and symbol of the non fungible token, as defined in ERC721. + string public constant name = "CryptoKitties"; + string public constant symbol = "CK"; + + // The contract that will return kitty metadata + ERC721Metadata public erc721Metadata; + + bytes4 constant InterfaceSignature_ERC165 = + bytes4(keccak256('supportsInterface(bytes4)')); + + bytes4 constant InterfaceSignature_ERC721 = + bytes4(keccak256('name()')) ^ + bytes4(keccak256('symbol()')) ^ + bytes4(keccak256('totalSupply()')) ^ + bytes4(keccak256('balanceOf(address)')) ^ + bytes4(keccak256('ownerOf(uint256)')) ^ + bytes4(keccak256('approve(address,uint256)')) ^ + bytes4(keccak256('transfer(address,uint256)')) ^ + bytes4(keccak256('transferFrom(address,address,uint256)')) ^ + bytes4(keccak256('tokensOfOwner(address)')) ^ + bytes4(keccak256('tokenMetadata(uint256,string)')); + + /// @notice Introspection interface as per ERC-165 (https://github.com/ethereum/EIPs/issues/165). + /// Returns true for any standardized interfaces implemented by this contract. We implement + /// ERC-165 (obviously!) and ERC-721. + function supportsInterface(bytes4 _interfaceID) external view returns (bool) + { + // DEBUG ONLY + //require((InterfaceSignature_ERC165 == 0x01ffc9a7) && (InterfaceSignature_ERC721 == 0x9a20483d)); + + return ((_interfaceID == InterfaceSignature_ERC165) || (_interfaceID == InterfaceSignature_ERC721)); + } + + /// @dev Set the address of the sibling contract that tracks metadata. + /// CEO only. + function setMetadataAddress(address _contractAddress) public onlyCEO { + erc721Metadata = ERC721Metadata(_contractAddress); + } + + // Internal utility functions: These functions all assume that their input arguments + // are valid. We leave it to public methods to sanitize their inputs and follow + // the required logic. + + /// @dev Checks if a given address is the current owner of a particular Kitty. + /// @param _claimant the address we are validating against. + /// @param _tokenId kitten id, only valid when > 0 + function _owns(address _claimant, uint256 _tokenId) internal view returns (bool) { + return kittyIndexToOwner[_tokenId] == _claimant; + } + + /// @dev Checks if a given address currently has transferApproval for a particular Kitty. + /// @param _claimant the address we are confirming kitten is approved for. + /// @param _tokenId kitten id, only valid when > 0 + function _approvedFor(address _claimant, uint256 _tokenId) internal view returns (bool) { + return kittyIndexToApproved[_tokenId] == _claimant; + } + + /// @dev Marks an address as being approved for transferFrom(), overwriting any previous + /// approval. Setting _approved to address(0) clears all transfer approval. + /// NOTE: _approve() does NOT send the Approval event. This is intentional because + /// _approve() and transferFrom() are used together for putting Kitties on auction, and + /// there is no value in spamming the log with Approval events in that case. + function _approve(uint256 _tokenId, address _approved) internal { + kittyIndexToApproved[_tokenId] = _approved; + } + + /// @notice Returns the number of Kitties owned by a specific address. + /// @param _owner The owner address to check. + /// @dev Required for ERC-721 compliance + function balanceOf(address _owner) public view returns (uint256 count) { + return ownershipTokenCount[_owner]; + } + + /// @notice Transfers a Kitty to another address. If transferring to a smart + /// contract be VERY CAREFUL to ensure that it is aware of ERC-721 (or + /// CryptoKitties specifically) or your Kitty may be lost forever. Seriously. + /// @param _to The address of the recipient, can be a user or contract. + /// @param _tokenId The ID of the Kitty to transfer. + /// @dev Required for ERC-721 compliance. + function transfer( + address _to, + uint256 _tokenId + ) + external + whenNotPaused + { + // Safety check to prevent against an unexpected 0x0 default. + require(_to != address(0)); + // Disallow transfers to this contract to prevent accidental misuse. + // The contract should never own any kitties (except very briefly + // after a gen0 cat is created and before it goes on auction). + require(_to != address(this)); + // Disallow transfers to the auction contracts to prevent accidental + // misuse. Auction contracts should only take ownership of kitties + // through the allow + transferFrom flow. + require(_to != address(saleAuction)); + require(_to != address(siringAuction)); + + // You can only send your own cat. + require(_owns(msg.sender, _tokenId)); + + // Reassign ownership, clear pending approvals, emit Transfer event. + _transfer(msg.sender, _to, _tokenId); + } + + /// @notice Grant another address the right to transfer a specific Kitty via + /// transferFrom(). This is the preferred flow for transfering NFTs to contracts. + /// @param _to The address to be granted transfer approval. Pass address(0) to + /// clear all approvals. + /// @param _tokenId The ID of the Kitty that can be transferred if this call succeeds. + /// @dev Required for ERC-721 compliance. + function approve( + address _to, + uint256 _tokenId + ) + external + whenNotPaused + { + // Only an owner can grant transfer approval. + require(_owns(msg.sender, _tokenId)); + + // Register the approval (replacing any previous approval). + _approve(_tokenId, _to); + + // Emit approval event. + Approval(msg.sender, _to, _tokenId); + } + + /// @notice Transfer a Kitty owned by another address, for which the calling address + /// has previously been granted transfer approval by the owner. + /// @param _from The address that owns the Kitty to be transfered. + /// @param _to The address that should take ownership of the Kitty. Can be any address, + /// including the caller. + /// @param _tokenId The ID of the Kitty to be transferred. + /// @dev Required for ERC-721 compliance. + function transferFrom( + address _from, + address _to, + uint256 _tokenId + ) + external + whenNotPaused + { + // Safety check to prevent against an unexpected 0x0 default. + require(_to != address(0)); + // Disallow transfers to this contract to prevent accidental misuse. + // The contract should never own any kitties (except very briefly + // after a gen0 cat is created and before it goes on auction). + require(_to != address(this)); + // Check for approval and valid ownership + require(_approvedFor(msg.sender, _tokenId)); + require(_owns(_from, _tokenId)); + + // Reassign ownership (also clears pending approvals and emits Transfer event). + _transfer(_from, _to, _tokenId); + } + + /// @notice Returns the total number of Kitties currently in existence. + /// @dev Required for ERC-721 compliance. + function totalSupply() public view returns (uint) { + return kitties.length - 1; + } + + /// @notice Returns the address currently assigned ownership of a given Kitty. + /// @dev Required for ERC-721 compliance. + function ownerOf(uint256 _tokenId) + external + view + returns (address owner) + { + owner = kittyIndexToOwner[_tokenId]; + + require(owner != address(0)); + } + + /// @notice Returns a list of all Kitty IDs assigned to an address. + /// @param _owner The owner whose Kitties we are interested in. + /// @dev This method MUST NEVER be called by smart contract code. First, it's fairly + /// expensive (it walks the entire Kitty array looking for cats belonging to owner), + /// but it also returns a dynamic array, which is only supported for web3 calls, and + /// not contract-to-contract calls. + function tokensOfOwner(address _owner) external view returns(uint256[] ownerTokens) { + uint256 tokenCount = balanceOf(_owner); + + if (tokenCount == 0) { + // Return an empty array + return new uint256[](0); + } else { + uint256[] memory result = new uint256[](tokenCount); + uint256 totalCats = totalSupply(); + uint256 resultIndex = 0; + + // We count on the fact that all cats have IDs starting at 1 and increasing + // sequentially up to the totalCat count. + uint256 catId; + + for (catId = 1; catId <= totalCats; catId++) { + if (kittyIndexToOwner[catId] == _owner) { + result[resultIndex] = catId; + resultIndex++; + } + } + + return result; + } + } + + /// @dev Adapted from memcpy() by @arachnid (Nick Johnson <[email protected]>) + /// This method is licenced under the Apache License. + /// Ref: https://github.com/Arachnid/solidity-stringutils/blob/2f6ca9accb48ae14c66f1437ec50ed19a0616f78/strings.sol + function _memcpy(uint _dest, uint _src, uint _len) private view { + // Copy word-length chunks while possible + for(; _len >= 32; _len -= 32) { + assembly { + mstore(_dest, mload(_src)) + } + _dest += 32; + _src += 32; + } + + // Copy remaining bytes + uint256 mask = 256 ** (32 - _len) - 1; + assembly { + let srcpart := and(mload(_src), not(mask)) + let destpart := and(mload(_dest), mask) + mstore(_dest, or(destpart, srcpart)) + } + } + + /// @dev Adapted from toString(slice) by @arachnid (Nick Johnson <[email protected]>) + /// This method is licenced under the Apache License. + /// Ref: https://github.com/Arachnid/solidity-stringutils/blob/2f6ca9accb48ae14c66f1437ec50ed19a0616f78/strings.sol + function _toString(bytes32[4] _rawBytes, uint256 _stringLength) private view returns (string) { + var outputString = new string(_stringLength); + uint256 outputPtr; + uint256 bytesPtr; + + assembly { + outputPtr := add(outputString, 32) + bytesPtr := _rawBytes + } + + _memcpy(outputPtr, bytesPtr, _stringLength); + + return outputString; + } + + /// @notice Returns a URI pointing to a metadata package for this token conforming to + /// ERC-721 (https://github.com/ethereum/EIPs/issues/721) + /// @param _tokenId The ID number of the Kitty whose metadata should be returned. + function tokenMetadata(uint256 _tokenId, string _preferredTransport) external view returns (string infoUrl) { + require(erc721Metadata != address(0)); + bytes32[4] memory buffer; + uint256 count; + (buffer, count) = erc721Metadata.getMetadata(_tokenId, _preferredTransport); + + return _toString(buffer, count); + } +} + + + +/// @title A facet of KittyCore that manages Kitty siring, gestation, and birth. +/// @author Axiom Zen (https://www.axiomzen.co) +/// @dev See the KittyCore contract documentation to understand how the various contract facets are arranged. +contract KittyBreeding is KittyOwnership { + + /// @dev The Pregnant event is fired when two cats successfully breed and the pregnancy + /// timer begins for the matron. + event Pregnant(address owner, uint256 matronId, uint256 sireId, uint256 cooldownEndBlock); + + /// @notice The minimum payment required to use breedWithAuto(). This fee goes towards + /// the gas cost paid by whatever calls giveBirth(), and can be dynamically updated by + /// the COO role as the gas price changes. + uint256 public autoBirthFee = 2 finney; + + // Keeps track of number of pregnant kitties. + uint256 public pregnantKitties; + + /// @dev The address of the sibling contract that is used to implement the sooper-sekret + /// genetic combination algorithm. + GeneScienceInterface public geneScience; + + /// @dev Update the address of the genetic contract, can only be called by the CEO. + /// @param _address An address of a GeneScience contract instance to be used from this point forward. + function setGeneScienceAddress(address _address) external onlyCEO { + GeneScienceInterface candidateContract = GeneScienceInterface(_address); + + // NOTE: verify that a contract is what we expect - https://github.com/Lunyr/crowdsale-contracts/blob/cfadd15986c30521d8ba7d5b6f57b4fefcc7ac38/contracts/LunyrToken.sol#L117 + require(candidateContract.isGeneScience()); + + // Set the new contract address + geneScience = candidateContract; + } + + /// @dev Checks that a given kitten is able to breed. Requires that the + /// current cooldown is finished (for sires) and also checks that there is + /// no pending pregnancy. + function _isReadyToBreed(Kitty _kit) internal view returns (bool) { + // In addition to checking the cooldownEndBlock, we also need to check to see if + // the cat has a pending birth; there can be some period of time between the end + // of the pregnacy timer and the birth event. + return (_kit.siringWithId == 0) && (_kit.cooldownEndBlock <= uint64(block.number)); + } + + /// @dev Check if a sire has authorized breeding with this matron. True if both sire + /// and matron have the same owner, or if the sire has given siring permission to + /// the matron's owner (via approveSiring()). + function _isSiringPermitted(uint256 _sireId, uint256 _matronId) internal view returns (bool) { + address matronOwner = kittyIndexToOwner[_matronId]; + address sireOwner = kittyIndexToOwner[_sireId]; + + // Siring is okay if they have same owner, or if the matron's owner was given + // permission to breed with this sire. + return (matronOwner == sireOwner || sireAllowedToAddress[_sireId] == matronOwner); + } + + /// @dev Set the cooldownEndTime for the given Kitty, based on its current cooldownIndex. + /// Also increments the cooldownIndex (unless it has hit the cap). + /// @param _kitten A reference to the Kitty in storage which needs its timer started. + function _triggerCooldown(Kitty storage _kitten) internal { + // Compute an estimation of the cooldown time in blocks (based on current cooldownIndex). + _kitten.cooldownEndBlock = uint64((cooldowns[_kitten.cooldownIndex]/secondsPerBlock) + block.number); + + // Increment the breeding count, clamping it at 13, which is the length of the + // cooldowns array. We could check the array size dynamically, but hard-coding + // this as a constant saves gas. Yay, Solidity! + if (_kitten.cooldownIndex < 13) { + _kitten.cooldownIndex += 1; + } + } + + /// @notice Grants approval to another user to sire with one of your Kitties. + /// @param _addr The address that will be able to sire with your Kitty. Set to + /// address(0) to clear all siring approvals for this Kitty. + /// @param _sireId A Kitty that you own that _addr will now be able to sire with. + function approveSiring(address _addr, uint256 _sireId) + external + whenNotPaused + { + require(_owns(msg.sender, _sireId)); + sireAllowedToAddress[_sireId] = _addr; + } + + /// @dev Updates the minimum payment required for calling giveBirthAuto(). Can only + /// be called by the COO address. (This fee is used to offset the gas cost incurred + /// by the autobirth daemon). + function setAutoBirthFee(uint256 val) external onlyCOO { + autoBirthFee = val; + } + + /// @dev Checks to see if a given Kitty is pregnant and (if so) if the gestation + /// period has passed. + function _isReadyToGiveBirth(Kitty _matron) private view returns (bool) { + return (_matron.siringWithId != 0) && (_matron.cooldownEndBlock <= uint64(block.number)); + } + + /// @notice Checks that a given kitten is able to breed (i.e. it is not pregnant or + /// in the middle of a siring cooldown). + /// @param _kittyId reference the id of the kitten, any user can inquire about it + function isReadyToBreed(uint256 _kittyId) + public + view + returns (bool) + { + require(_kittyId > 0); + Kitty storage kit = kitties[_kittyId]; + return _isReadyToBreed(kit); + } + + /// @dev Checks whether a kitty is currently pregnant. + /// @param _kittyId reference the id of the kitten, any user can inquire about it + function isPregnant(uint256 _kittyId) + public + view + returns (bool) + { + require(_kittyId > 0); + // A kitty is pregnant if and only if this field is set + return kitties[_kittyId].siringWithId != 0; + } + + /// @dev Internal check to see if a given sire and matron are a valid mating pair. DOES NOT + /// check ownership permissions (that is up to the caller). + /// @param _matron A reference to the Kitty struct of the potential matron. + /// @param _matronId The matron's ID. + /// @param _sire A reference to the Kitty struct of the potential sire. + /// @param _sireId The sire's ID + function _isValidMatingPair( + Kitty storage _matron, + uint256 _matronId, + Kitty storage _sire, + uint256 _sireId + ) + private + view + returns(bool) + { + // A Kitty can't breed with itself! + if (_matronId == _sireId) { + return false; + } + + // Kitties can't breed with their parents. + if (_matron.matronId == _sireId || _matron.sireId == _sireId) { + return false; + } + if (_sire.matronId == _matronId || _sire.sireId == _matronId) { + return false; + } + + // We can short circuit the sibling check (below) if either cat is + // gen zero (has a matron ID of zero). + if (_sire.matronId == 0 || _matron.matronId == 0) { + return true; + } + + // Kitties can't breed with full or half siblings. + if (_sire.matronId == _matron.matronId || _sire.matronId == _matron.sireId) { + return false; + } + if (_sire.sireId == _matron.matronId || _sire.sireId == _matron.sireId) { + return false; + } + + // Everything seems cool! Let's get DTF. + return true; + } + + /// @dev Internal check to see if a given sire and matron are a valid mating pair for + /// breeding via auction (i.e. skips ownership and siring approval checks). + function _canBreedWithViaAuction(uint256 _matronId, uint256 _sireId) + internal + view + returns (bool) + { + Kitty storage matron = kitties[_matronId]; + Kitty storage sire = kitties[_sireId]; + return _isValidMatingPair(matron, _matronId, sire, _sireId); + } + + /// @notice Checks to see if two cats can breed together, including checks for + /// ownership and siring approvals. Does NOT check that both cats are ready for + /// breeding (i.e. breedWith could still fail until the cooldowns are finished). + /// TODO: Shouldn't this check pregnancy and cooldowns?!? + /// @param _matronId The ID of the proposed matron. + /// @param _sireId The ID of the proposed sire. + function canBreedWith(uint256 _matronId, uint256 _sireId) + external + view + returns(bool) + { + require(_matronId > 0); + require(_sireId > 0); + Kitty storage matron = kitties[_matronId]; + Kitty storage sire = kitties[_sireId]; + return _isValidMatingPair(matron, _matronId, sire, _sireId) && + _isSiringPermitted(_sireId, _matronId); + } + + /// @dev Internal utility function to initiate breeding, assumes that all breeding + /// requirements have been checked. + function _breedWith(uint256 _matronId, uint256 _sireId) internal { + // Grab a reference to the Kitties from storage. + Kitty storage sire = kitties[_sireId]; + Kitty storage matron = kitties[_matronId]; + + // Mark the matron as pregnant, keeping track of who the sire is. + matron.siringWithId = uint32(_sireId); + + // Trigger the cooldown for both parents. + _triggerCooldown(sire); + _triggerCooldown(matron); + + // Clear siring permission for both parents. This may not be strictly necessary + // but it's likely to avoid confusion! + delete sireAllowedToAddress[_matronId]; + delete sireAllowedToAddress[_sireId]; + + // Every time a kitty gets pregnant, counter is incremented. + pregnantKitties++; + + // Emit the pregnancy event. + Pregnant(kittyIndexToOwner[_matronId], _matronId, _sireId, matron.cooldownEndBlock); + } + + /// @notice Breed a Kitty you own (as matron) with a sire that you own, or for which you + /// have previously been given Siring approval. Will either make your cat pregnant, or will + /// fail entirely. Requires a pre-payment of the fee given out to the first caller of giveBirth() + /// @param _matronId The ID of the Kitty acting as matron (will end up pregnant if successful) + /// @param _sireId The ID of the Kitty acting as sire (will begin its siring cooldown if successful) + function breedWithAuto(uint256 _matronId, uint256 _sireId) + external + payable + whenNotPaused + { + // Checks for payment. + require(msg.value >= autoBirthFee); + + // Caller must own the matron. + require(_owns(msg.sender, _matronId)); + + // Neither sire nor matron are allowed to be on auction during a normal + // breeding operation, but we don't need to check that explicitly. + // For matron: The caller of this function can't be the owner of the matron + // because the owner of a Kitty on auction is the auction house, and the + // auction house will never call breedWith(). + // For sire: Similarly, a sire on auction will be owned by the auction house + // and the act of transferring ownership will have cleared any oustanding + // siring approval. + // Thus we don't need to spend gas explicitly checking to see if either cat + // is on auction. + + // Check that matron and sire are both owned by caller, or that the sire + // has given siring permission to caller (i.e. matron's owner). + // Will fail for _sireId = 0 + require(_isSiringPermitted(_sireId, _matronId)); + + // Grab a reference to the potential matron + Kitty storage matron = kitties[_matronId]; + + // Make sure matron isn't pregnant, or in the middle of a siring cooldown + require(_isReadyToBreed(matron)); + + // Grab a reference to the potential sire + Kitty storage sire = kitties[_sireId]; + + // Make sure sire isn't pregnant, or in the middle of a siring cooldown + require(_isReadyToBreed(sire)); + + // Test that these cats are a valid mating pair. + require(_isValidMatingPair( + matron, + _matronId, + sire, + _sireId + )); + + // All checks passed, kitty gets pregnant! + _breedWith(_matronId, _sireId); + } + + /// @notice Have a pregnant Kitty give birth! + /// @param _matronId A Kitty ready to give birth. + /// @return The Kitty ID of the new kitten. + /// @dev Looks at a given Kitty and, if pregnant and if the gestation period has passed, + /// combines the genes of the two parents to create a new kitten. The new Kitty is assigned + /// to the current owner of the matron. Upon successful completion, both the matron and the + /// new kitten will be ready to breed again. Note that anyone can call this function (if they + /// are willing to pay the gas!), but the new kitten always goes to the mother's owner. + function giveBirth(uint256 _matronId) + external + whenNotPaused + returns(uint256) + { + // Grab a reference to the matron in storage. + Kitty storage matron = kitties[_matronId]; + + // Check that the matron is a valid cat. + require(matron.birthTime != 0); + + // Check that the matron is pregnant, and that its time has come! + require(_isReadyToGiveBirth(matron)); + + // Grab a reference to the sire in storage. + uint256 sireId = matron.siringWithId; + Kitty storage sire = kitties[sireId]; + + // Determine the higher generation number of the two parents + uint16 parentGen = matron.generation; + if (sire.generation > matron.generation) { + parentGen = sire.generation; + } + + // Call the sooper-sekret gene mixing operation. + uint256 childGenes = geneScience.mixGenes(matron.genes, sire.genes, matron.cooldownEndBlock - 1); + + // Make the new kitten! + address owner = kittyIndexToOwner[_matronId]; + uint256 kittenId = _createKitty(_matronId, matron.siringWithId, parentGen + 1, childGenes, owner); + + // Clear the reference to sire from the matron (REQUIRED! Having siringWithId + // set is what marks a matron as being pregnant.) + delete matron.siringWithId; + + // Every time a kitty gives birth counter is decremented. + pregnantKitties--; + + // Send the balance fee to the person who made birth happen. + msg.sender.send(autoBirthFee); + + // return the new kitten's ID + return kittenId; + } +} + + + + + + + + + + +/// @title Auction Core +/// @dev Contains models, variables, and internal methods for the auction. +/// @notice We omit a fallback function to prevent accidental sends to this contract. +contract ClockAuctionBase { + + // Represents an auction on an NFT + struct Auction { + // Current owner of NFT + address seller; + // Price (in wei) at beginning of auction + uint128 startingPrice; + // Price (in wei) at end of auction + uint128 endingPrice; + // Duration (in seconds) of auction + uint64 duration; + // Time when auction started + // NOTE: 0 if this auction has been concluded + uint64 startedAt; + } + + // Reference to contract tracking NFT ownership + ERC721 public nonFungibleContract; + + // Cut owner takes on each auction, measured in basis points (1/100 of a percent). + // Values 0-10,000 map to 0%-100% + uint256 public ownerCut; + + // Map from token ID to their corresponding auction. + mapping (uint256 => Auction) tokenIdToAuction; + + event AuctionCreated(uint256 tokenId, uint256 startingPrice, uint256 endingPrice, uint256 duration); + event AuctionSuccessful(uint256 tokenId, uint256 totalPrice, address winner); + event AuctionCancelled(uint256 tokenId); + + /// @dev Returns true if the claimant owns the token. + /// @param _claimant - Address claiming to own the token. + /// @param _tokenId - ID of token whose ownership to verify. + function _owns(address _claimant, uint256 _tokenId) internal view returns (bool) { + return (nonFungibleContract.ownerOf(_tokenId) == _claimant); + } + + /// @dev Escrows the NFT, assigning ownership to this contract. + /// Throws if the escrow fails. + /// @param _owner - Current owner address of token to escrow. + /// @param _tokenId - ID of token whose approval to verify. + function _escrow(address _owner, uint256 _tokenId) internal { + // it will throw if transfer fails + nonFungibleContract.transferFrom(_owner, this, _tokenId); + } + + /// @dev Transfers an NFT owned by this contract to another address. + /// Returns true if the transfer succeeds. + /// @param _receiver - Address to transfer NFT to. + /// @param _tokenId - ID of token to transfer. + function _transfer(address _receiver, uint256 _tokenId) internal { + // it will throw if transfer fails + nonFungibleContract.transfer(_receiver, _tokenId); + } + + /// @dev Adds an auction to the list of open auctions. Also fires the + /// AuctionCreated event. + /// @param _tokenId The ID of the token to be put on auction. + /// @param _auction Auction to add. + function _addAuction(uint256 _tokenId, Auction _auction) internal { + // Require that all auctions have a duration of + // at least one minute. (Keeps our math from getting hairy!) + require(_auction.duration >= 1 minutes); + + tokenIdToAuction[_tokenId] = _auction; + + AuctionCreated( + uint256(_tokenId), + uint256(_auction.startingPrice), + uint256(_auction.endingPrice), + uint256(_auction.duration) + ); + } + + /// @dev Cancels an auction unconditionally. + function _cancelAuction(uint256 _tokenId, address _seller) internal { + _removeAuction(_tokenId); + _transfer(_seller, _tokenId); + AuctionCancelled(_tokenId); + } + + /// @dev Computes the price and transfers winnings. + /// Does NOT transfer ownership of token. + function _bid(uint256 _tokenId, uint256 _bidAmount) + internal + returns (uint256) + { + // Get a reference to the auction struct + Auction storage auction = tokenIdToAuction[_tokenId]; + + // Explicitly check that this auction is currently live. + // (Because of how Ethereum mappings work, we can't just count + // on the lookup above failing. An invalid _tokenId will just + // return an auction object that is all zeros.) + require(_isOnAuction(auction)); + + // Check that the bid is greater than or equal to the current price + uint256 price = _currentPrice(auction); + require(_bidAmount >= price); + + // Grab a reference to the seller before the auction struct + // gets deleted. + address seller = auction.seller; + + // The bid is good! Remove the auction before sending the fees + // to the sender so we can't have a reentrancy attack. + _removeAuction(_tokenId); + + // Transfer proceeds to seller (if there are any!) + if (price > 0) { + // Calculate the auctioneer's cut. + // (NOTE: _computeCut() is guaranteed to return a + // value <= price, so this subtraction can't go negative.) + uint256 auctioneerCut = _computeCut(price); + uint256 sellerProceeds = price - auctioneerCut; + + // NOTE: Doing a transfer() in the middle of a complex + // method like this is generally discouraged because of + // reentrancy attacks and DoS attacks if the seller is + // a contract with an invalid fallback function. We explicitly + // guard against reentrancy attacks by removing the auction + // before calling transfer(), and the only thing the seller + // can DoS is the sale of their own asset! (And if it's an + // accident, they can call cancelAuction(). ) + seller.transfer(sellerProceeds); + } + + // Calculate any excess funds included with the bid. If the excess + // is anything worth worrying about, transfer it back to bidder. + // NOTE: We checked above that the bid amount is greater than or + // equal to the price so this cannot underflow. + uint256 bidExcess = _bidAmount - price; + + // Return the funds. Similar to the previous transfer, this is + // not susceptible to a re-entry attack because the auction is + // removed before any transfers occur. + msg.sender.transfer(bidExcess); + + // Tell the world! + AuctionSuccessful(_tokenId, price, msg.sender); + + return price; + } + + /// @dev Removes an auction from the list of open auctions. + /// @param _tokenId - ID of NFT on auction. + function _removeAuction(uint256 _tokenId) internal { + delete tokenIdToAuction[_tokenId]; + } + + /// @dev Returns true if the NFT is on auction. + /// @param _auction - Auction to check. + function _isOnAuction(Auction storage _auction) internal view returns (bool) { + return (_auction.startedAt > 0); + } + + /// @dev Returns current price of an NFT on auction. Broken into two + /// functions (this one, that computes the duration from the auction + /// structure, and the other that does the price computation) so we + /// can easily test that the price computation works correctly. + function _currentPrice(Auction storage _auction) + internal + view + returns (uint256) + { + uint256 secondsPassed = 0; + + // A bit of insurance against negative values (or wraparound). + // Probably not necessary (since Ethereum guarnatees that the + // now variable doesn't ever go backwards). + if (now > _auction.startedAt) { + secondsPassed = now - _auction.startedAt; + } + + return _computeCurrentPrice( + _auction.startingPrice, + _auction.endingPrice, + _auction.duration, + secondsPassed + ); + } + + /// @dev Computes the current price of an auction. Factored out + /// from _currentPrice so we can run extensive unit tests. + /// When testing, make this function public and turn on + /// `Current price computation` test suite. + function _computeCurrentPrice( + uint256 _startingPrice, + uint256 _endingPrice, + uint256 _duration, + uint256 _secondsPassed + ) + internal + pure + returns (uint256) + { + // NOTE: We don't use SafeMath (or similar) in this function because + // all of our public functions carefully cap the maximum values for + // time (at 64-bits) and currency (at 128-bits). _duration is + // also known to be non-zero (see the require() statement in + // _addAuction()) + if (_secondsPassed >= _duration) { + // We've reached the end of the dynamic pricing portion + // of the auction, just return the end price. + return _endingPrice; + } else { + // Starting price can be higher than ending price (and often is!), so + // this delta can be negative. + int256 totalPriceChange = int256(_endingPrice) - int256(_startingPrice); + + // This multiplication can't overflow, _secondsPassed will easily fit within + // 64-bits, and totalPriceChange will easily fit within 128-bits, their product + // will always fit within 256-bits. + int256 currentPriceChange = totalPriceChange * int256(_secondsPassed) / int256(_duration); + + // currentPriceChange can be negative, but if so, will have a magnitude + // less that _startingPrice. Thus, this result will always end up positive. + int256 currentPrice = int256(_startingPrice) + currentPriceChange; + + return uint256(currentPrice); + } + } + + /// @dev Computes owner's cut of a sale. + /// @param _price - Sale price of NFT. + function _computeCut(uint256 _price) internal view returns (uint256) { + // NOTE: We don't use SafeMath (or similar) in this function because + // all of our entry functions carefully cap the maximum values for + // currency (at 128-bits), and ownerCut <= 10000 (see the require() + // statement in the ClockAuction constructor). The result of this + // function is always guaranteed to be <= _price. + return _price * ownerCut / 10000; + } + +} + + + + + + + +/** + * @title Pausable + * @dev Base contract which allows children to implement an emergency stop mechanism. + */ +contract Pausable is Ownable { + event Pause(); + event Unpause(); + + bool public paused = false; + + + /** + * @dev modifier to allow actions only when the contract IS paused + */ + modifier whenNotPaused() { + require(!paused); + _; + } + + /** + * @dev modifier to allow actions only when the contract IS NOT paused + */ + modifier whenPaused { + require(paused); + _; + } + + /** + * @dev called by the owner to pause, triggers stopped state + */ + function pause() onlyOwner whenNotPaused returns (bool) { + paused = true; + Pause(); + return true; + } + + /** + * @dev called by the owner to unpause, returns to normal state + */ + function unpause() onlyOwner whenPaused returns (bool) { + paused = false; + Unpause(); + return true; + } +} + + +/// @title Clock auction for non-fungible tokens. +/// @notice We omit a fallback function to prevent accidental sends to this contract. +contract ClockAuction is Pausable, ClockAuctionBase { + + /// @dev The ERC-165 interface signature for ERC-721. + /// Ref: https://github.com/ethereum/EIPs/issues/165 + /// Ref: https://github.com/ethereum/EIPs/issues/721 + bytes4 constant InterfaceSignature_ERC721 = bytes4(0x9a20483d); + + /// @dev Constructor creates a reference to the NFT ownership contract + /// and verifies the owner cut is in the valid range. + /// @param _nftAddress - address of a deployed contract implementing + /// the Nonfungible Interface. + /// @param _cut - percent cut the owner takes on each auction, must be + /// between 0-10,000. + function ClockAuction(address _nftAddress, uint256 _cut) public { + require(_cut <= 10000); + ownerCut = _cut; + + ERC721 candidateContract = ERC721(_nftAddress); + require(candidateContract.supportsInterface(InterfaceSignature_ERC721)); + nonFungibleContract = candidateContract; + } + + /// @dev Remove all Ether from the contract, which is the owner's cuts + /// as well as any Ether sent directly to the contract address. + /// Always transfers to the NFT contract, but can be called either by + /// the owner or the NFT contract. + function withdrawBalance() external { + address nftAddress = address(nonFungibleContract); + + require( + msg.sender == owner || + msg.sender == nftAddress + ); + // We are using this boolean method to make sure that even if one fails it will still work + bool res = nftAddress.send(this.balance); + } + + /// @dev Creates and begins a new auction. + /// @param _tokenId - ID of token to auction, sender must be owner. + /// @param _startingPrice - Price of item (in wei) at beginning of auction. + /// @param _endingPrice - Price of item (in wei) at end of auction. + /// @param _duration - Length of time to move between starting + /// price and ending price (in seconds). + /// @param _seller - Seller, if not the message sender + function createAuction( + uint256 _tokenId, + uint256 _startingPrice, + uint256 _endingPrice, + uint256 _duration, + address _seller + ) + external + whenNotPaused + { + // Sanity check that no inputs overflow how many bits we've allocated + // to store them in the auction struct. + require(_startingPrice == uint256(uint128(_startingPrice))); + require(_endingPrice == uint256(uint128(_endingPrice))); + require(_duration == uint256(uint64(_duration))); + + require(_owns(msg.sender, _tokenId)); + _escrow(msg.sender, _tokenId); + Auction memory auction = Auction( + _seller, + uint128(_startingPrice), + uint128(_endingPrice), + uint64(_duration), + uint64(now) + ); + _addAuction(_tokenId, auction); + } + + /// @dev Bids on an open auction, completing the auction and transferring + /// ownership of the NFT if enough Ether is supplied. + /// @param _tokenId - ID of token to bid on. + function bid(uint256 _tokenId) + external + payable + whenNotPaused + { + // _bid will throw if the bid or funds transfer fails + _bid(_tokenId, msg.value); + _transfer(msg.sender, _tokenId); + } + + /// @dev Cancels an auction that hasn't been won yet. + /// Returns the NFT to original owner. + /// @notice This is a state-modifying function that can + /// be called while the contract is paused. + /// @param _tokenId - ID of token on auction + function cancelAuction(uint256 _tokenId) + external + { + Auction storage auction = tokenIdToAuction[_tokenId]; + require(_isOnAuction(auction)); + address seller = auction.seller; + require(msg.sender == seller); + _cancelAuction(_tokenId, seller); + } + + /// @dev Cancels an auction when the contract is paused. + /// Only the owner may do this, and NFTs are returned to + /// the seller. This should only be used in emergencies. + /// @param _tokenId - ID of the NFT on auction to cancel. + function cancelAuctionWhenPaused(uint256 _tokenId) + whenPaused + onlyOwner + external + { + Auction storage auction = tokenIdToAuction[_tokenId]; + require(_isOnAuction(auction)); + _cancelAuction(_tokenId, auction.seller); + } + + /// @dev Returns auction info for an NFT on auction. + /// @param _tokenId - ID of NFT on auction. + function getAuction(uint256 _tokenId) + external + view + returns + ( + address seller, + uint256 startingPrice, + uint256 endingPrice, + uint256 duration, + uint256 startedAt + ) { + Auction storage auction = tokenIdToAuction[_tokenId]; + require(_isOnAuction(auction)); + return ( + auction.seller, + auction.startingPrice, + auction.endingPrice, + auction.duration, + auction.startedAt + ); + } + + /// @dev Returns the current price of an auction. + /// @param _tokenId - ID of the token price we are checking. + function getCurrentPrice(uint256 _tokenId) + external + view + returns (uint256) + { + Auction storage auction = tokenIdToAuction[_tokenId]; + require(_isOnAuction(auction)); + return _currentPrice(auction); + } + +} + + +/// @title Reverse auction modified for siring +/// @notice We omit a fallback function to prevent accidental sends to this contract. +contract SiringClockAuction is ClockAuction { + + // @dev Sanity check that allows us to ensure that we are pointing to the + // right auction in our setSiringAuctionAddress() call. + bool public isSiringClockAuction = true; + + // Delegate constructor + function SiringClockAuction(address _nftAddr, uint256 _cut) public + ClockAuction(_nftAddr, _cut) {} + + /// @dev Creates and begins a new auction. Since this function is wrapped, + /// require sender to be KittyCore contract. + /// @param _tokenId - ID of token to auction, sender must be owner. + /// @param _startingPrice - Price of item (in wei) at beginning of auction. + /// @param _endingPrice - Price of item (in wei) at end of auction. + /// @param _duration - Length of auction (in seconds). + /// @param _seller - Seller, if not the message sender + function createAuction( + uint256 _tokenId, + uint256 _startingPrice, + uint256 _endingPrice, + uint256 _duration, + address _seller + ) + external + { + // Sanity check that no inputs overflow how many bits we've allocated + // to store them in the auction struct. + require(_startingPrice == uint256(uint128(_startingPrice))); + require(_endingPrice == uint256(uint128(_endingPrice))); + require(_duration == uint256(uint64(_duration))); + + require(msg.sender == address(nonFungibleContract)); + _escrow(_seller, _tokenId); + Auction memory auction = Auction( + _seller, + uint128(_startingPrice), + uint128(_endingPrice), + uint64(_duration), + uint64(now) + ); + _addAuction(_tokenId, auction); + } + + /// @dev Places a bid for siring. Requires the sender + /// is the KittyCore contract because all bid methods + /// should be wrapped. Also returns the kitty to the + /// seller rather than the winner. + function bid(uint256 _tokenId) + external + payable + { + require(msg.sender == address(nonFungibleContract)); + address seller = tokenIdToAuction[_tokenId].seller; + // _bid checks that token ID is valid and will throw if bid fails + _bid(_tokenId, msg.value); + // We transfer the kitty back to the seller, the winner will get + // the offspring + _transfer(seller, _tokenId); + } + +} + + + + + +/// @title Clock auction modified for sale of kitties +/// @notice We omit a fallback function to prevent accidental sends to this contract. +contract SaleClockAuction is ClockAuction { + + // @dev Sanity check that allows us to ensure that we are pointing to the + // right auction in our setSaleAuctionAddress() call. + bool public isSaleClockAuction = true; + + // Tracks last 5 sale price of gen0 kitty sales + uint256 public gen0SaleCount; + uint256[5] public lastGen0SalePrices; + + // Delegate constructor + function SaleClockAuction(address _nftAddr, uint256 _cut) public + ClockAuction(_nftAddr, _cut) {} + + /// @dev Creates and begins a new auction. + /// @param _tokenId - ID of token to auction, sender must be owner. + /// @param _startingPrice - Price of item (in wei) at beginning of auction. + /// @param _endingPrice - Price of item (in wei) at end of auction. + /// @param _duration - Length of auction (in seconds). + /// @param _seller - Seller, if not the message sender + function createAuction( + uint256 _tokenId, + uint256 _startingPrice, + uint256 _endingPrice, + uint256 _duration, + address _seller + ) + external + { + // Sanity check that no inputs overflow how many bits we've allocated + // to store them in the auction struct. + require(_startingPrice == uint256(uint128(_startingPrice))); + require(_endingPrice == uint256(uint128(_endingPrice))); + require(_duration == uint256(uint64(_duration))); + + require(msg.sender == address(nonFungibleContract)); + _escrow(_seller, _tokenId); + Auction memory auction = Auction( + _seller, + uint128(_startingPrice), + uint128(_endingPrice), + uint64(_duration), + uint64(now) + ); + _addAuction(_tokenId, auction); + } + + /// @dev Updates lastSalePrice if seller is the nft contract + /// Otherwise, works the same as default bid method. + function bid(uint256 _tokenId) + external + payable + { + // _bid verifies token ID size + address seller = tokenIdToAuction[_tokenId].seller; + uint256 price = _bid(_tokenId, msg.value); + _transfer(msg.sender, _tokenId); + + // If not a gen0 auction, exit + if (seller == address(nonFungibleContract)) { + // Track gen0 sale prices + lastGen0SalePrices[gen0SaleCount % 5] = price; + gen0SaleCount++; + } + } + + function averageGen0SalePrice() external view returns (uint256) { + uint256 sum = 0; + for (uint256 i = 0; i < 5; i++) { + sum += lastGen0SalePrices[i]; + } + return sum / 5; + } + +} + + +/// @title Handles creating auctions for sale and siring of kitties. +/// This wrapper of ReverseAuction exists only so that users can create +/// auctions with only one transaction. +contract KittyAuction is KittyBreeding { + + // @notice The auction contract variables are defined in KittyBase to allow + // us to refer to them in KittyOwnership to prevent accidental transfers. + // `saleAuction` refers to the auction for gen0 and p2p sale of kitties. + // `siringAuction` refers to the auction for siring rights of kitties. + + /// @dev Sets the reference to the sale auction. + /// @param _address - Address of sale contract. + function setSaleAuctionAddress(address _address) external onlyCEO { + SaleClockAuction candidateContract = SaleClockAuction(_address); + + // NOTE: verify that a contract is what we expect - https://github.com/Lunyr/crowdsale-contracts/blob/cfadd15986c30521d8ba7d5b6f57b4fefcc7ac38/contracts/LunyrToken.sol#L117 + require(candidateContract.isSaleClockAuction()); + + // Set the new contract address + saleAuction = candidateContract; + } + + /// @dev Sets the reference to the siring auction. + /// @param _address - Address of siring contract. + function setSiringAuctionAddress(address _address) external onlyCEO { + SiringClockAuction candidateContract = SiringClockAuction(_address); + + // NOTE: verify that a contract is what we expect - https://github.com/Lunyr/crowdsale-contracts/blob/cfadd15986c30521d8ba7d5b6f57b4fefcc7ac38/contracts/LunyrToken.sol#L117 + require(candidateContract.isSiringClockAuction()); + + // Set the new contract address + siringAuction = candidateContract; + } + + /// @dev Put a kitty up for auction. + /// Does some ownership trickery to create auctions in one tx. + function createSaleAuction( + uint256 _kittyId, + uint256 _startingPrice, + uint256 _endingPrice, + uint256 _duration + ) + external + whenNotPaused + { + // Auction contract checks input sizes + // If kitty is already on any auction, this will throw + // because it will be owned by the auction contract. + require(_owns(msg.sender, _kittyId)); + // Ensure the kitty is not pregnant to prevent the auction + // contract accidentally receiving ownership of the child. + // NOTE: the kitty IS allowed to be in a cooldown. + require(!isPregnant(_kittyId)); + _approve(_kittyId, saleAuction); + // Sale auction throws if inputs are invalid and clears + // transfer and sire approval after escrowing the kitty. + saleAuction.createAuction( + _kittyId, + _startingPrice, + _endingPrice, + _duration, + msg.sender + ); + } + + /// @dev Put a kitty up for auction to be sire. + /// Performs checks to ensure the kitty can be sired, then + /// delegates to reverse auction. + function createSiringAuction( + uint256 _kittyId, + uint256 _startingPrice, + uint256 _endingPrice, + uint256 _duration + ) + external + whenNotPaused + { + // Auction contract checks input sizes + // If kitty is already on any auction, this will throw + // because it will be owned by the auction contract. + require(_owns(msg.sender, _kittyId)); + require(isReadyToBreed(_kittyId)); + _approve(_kittyId, siringAuction); + // Siring auction throws if inputs are invalid and clears + // transfer and sire approval after escrowing the kitty. + siringAuction.createAuction( + _kittyId, + _startingPrice, + _endingPrice, + _duration, + msg.sender + ); + } + + /// @dev Completes a siring auction by bidding. + /// Immediately breeds the winning matron with the sire on auction. + /// @param _sireId - ID of the sire on auction. + /// @param _matronId - ID of the matron owned by the bidder. + function bidOnSiringAuction( + uint256 _sireId, + uint256 _matronId + ) + external + payable + whenNotPaused + { + // Auction contract checks input sizes + require(_owns(msg.sender, _matronId)); + require(isReadyToBreed(_matronId)); + require(_canBreedWithViaAuction(_matronId, _sireId)); + + // Define the current price of the auction. + uint256 currentPrice = siringAuction.getCurrentPrice(_sireId); + require(msg.value >= currentPrice + autoBirthFee); + + // Siring auction will throw if the bid fails. + siringAuction.bid.value(msg.value - autoBirthFee)(_sireId); + _breedWith(uint32(_matronId), uint32(_sireId)); + } + + /// @dev Transfers the balance of the sale auction contract + /// to the KittyCore contract. We use two-step withdrawal to + /// prevent two transfer calls in the auction bid function. + function withdrawAuctionBalances() external onlyCLevel { + saleAuction.withdrawBalance(); + siringAuction.withdrawBalance(); + } +} + + +/// @title all functions related to creating kittens +contract KittyMinting is KittyAuction { + + // Limits the number of cats the contract owner can ever create. + uint256 public constant PROMO_CREATION_LIMIT = 5000; + uint256 public constant GEN0_CREATION_LIMIT = 45000; + + // Constants for gen0 auctions. + uint256 public constant GEN0_STARTING_PRICE = 10 finney; + uint256 public constant GEN0_AUCTION_DURATION = 1 days; + + // Counts the number of cats the contract owner has created. + uint256 public promoCreatedCount; + uint256 public gen0CreatedCount; + + /// @dev we can create promo kittens, up to a limit. Only callable by COO + /// @param _genes the encoded genes of the kitten to be created, any value is accepted + /// @param _owner the future owner of the created kittens. Default to contract COO + function createPromoKitty(uint256 _genes, address _owner) external onlyCOO { + address kittyOwner = _owner; + if (kittyOwner == address(0)) { + kittyOwner = cooAddress; + } + require(promoCreatedCount < PROMO_CREATION_LIMIT); + + promoCreatedCount++; + _createKitty(0, 0, 0, _genes, kittyOwner); + } + + /// @dev Creates a new gen0 kitty with the given genes and + /// creates an auction for it. + function createGen0Auction(uint256 _genes) external onlyCOO { + require(gen0CreatedCount < GEN0_CREATION_LIMIT); + + uint256 kittyId = _createKitty(0, 0, 0, _genes, address(this)); + _approve(kittyId, saleAuction); + + saleAuction.createAuction( + kittyId, + _computeNextGen0Price(), + 0, + GEN0_AUCTION_DURATION, + address(this) + ); + + gen0CreatedCount++; + } + + /// @dev Computes the next gen0 auction starting price, given + /// the average of the past 5 prices + 50%. + function _computeNextGen0Price() internal view returns (uint256) { + uint256 avePrice = saleAuction.averageGen0SalePrice(); + + // Sanity check to ensure we don't overflow arithmetic + require(avePrice == uint256(uint128(avePrice))); + + uint256 nextPrice = avePrice + (avePrice / 2); + + // We never auction for less than starting price + if (nextPrice < GEN0_STARTING_PRICE) { + nextPrice = GEN0_STARTING_PRICE; + } + + return nextPrice; + } +} + + +/// @title CryptoKitties: Collectible, breedable, and oh-so-adorable cats on the Ethereum blockchain. +/// @author Axiom Zen (https://www.axiomzen.co) +/// @dev The main CryptoKitties contract, keeps track of kittens so they don't wander around and get lost. +contract KittyCore is KittyMinting { + + // This is the main CryptoKitties contract. In order to keep our code seperated into logical sections, + // we've broken it up in two ways. First, we have several seperately-instantiated sibling contracts + // that handle auctions and our super-top-secret genetic combination algorithm. The auctions are + // seperate since their logic is somewhat complex and there's always a risk of subtle bugs. By keeping + // them in their own contracts, we can upgrade them without disrupting the main contract that tracks + // kitty ownership. The genetic combination algorithm is kept seperate so we can open-source all of + // the rest of our code without making it _too_ easy for folks to figure out how the genetics work. + // Don't worry, I'm sure someone will reverse engineer it soon enough! + // + // Secondly, we break the core contract into multiple files using inheritence, one for each major + // facet of functionality of CK. This allows us to keep related code bundled together while still + // avoiding a single giant file with everything in it. The breakdown is as follows: + // + // - KittyBase: This is where we define the most fundamental code shared throughout the core + // functionality. This includes our main data storage, constants and data types, plus + // internal functions for managing these items. + // + // - KittyAccessControl: This contract manages the various addresses and constraints for operations + // that can be executed only by specific roles. Namely CEO, CFO and COO. + // + // - KittyOwnership: This provides the methods required for basic non-fungible token + // transactions, following the draft ERC-721 spec (https://github.com/ethereum/EIPs/issues/721). + // + // - KittyBreeding: This file contains the methods necessary to breed cats together, including + // keeping track of siring offers, and relies on an external genetic combination contract. + // + // - KittyAuctions: Here we have the public methods for auctioning or bidding on cats or siring + // services. The actual auction functionality is handled in two sibling contracts (one + // for sales and one for siring), while auction creation and bidding is mostly mediated + // through this facet of the core contract. + // + // - KittyMinting: This final facet contains the functionality we use for creating new gen0 cats. + // We can make up to 5000 "promo" cats that can be given away (especially important when + // the community is new), and all others can only be created and then immediately put up + // for auction via an algorithmically determined starting price. Regardless of how they + // are created, there is a hard limit of 50k gen0 cats. After that, it's all up to the + // community to breed, breed, breed! + + // Set in case the core contract is broken and an upgrade is required + address public newContractAddress; + + /// @notice Creates the main CryptoKitties smart contract instance. + function KittyCore() public { + // Starts paused. + paused = true; + + // the creator of the contract is the initial CEO + ceoAddress = msg.sender; + + // the creator of the contract is also the initial COO + cooAddress = msg.sender; + + // start with the mythical kitten 0 - so we don't have generation-0 parent issues + _createKitty(0, 0, 0, uint256(-1), address(0)); + } + + /// @dev Used to mark the smart contract as upgraded, in case there is a serious + /// breaking bug. This method does nothing but keep track of the new contract and + /// emit a message indicating that the new address is set. It's up to clients of this + /// contract to update to the new contract address in that case. (This contract will + /// be paused indefinitely if such an upgrade takes place.) + /// @param _v2Address new address + function setNewAddress(address _v2Address) external onlyCEO whenPaused { + // See README.md for updgrade plan + newContractAddress = _v2Address; + ContractUpgrade(_v2Address); + } + + /// @notice No tipping! + /// @dev Reject all Ether from being sent here, unless it's from one of the + /// two auction contracts. (Hopefully, we can prevent user accidents.) + function() external payable { + require( + msg.sender == address(saleAuction) || + msg.sender == address(siringAuction) + ); + } + + /// @notice Returns all the relevant information about a specific kitty. + /// @param _id The ID of the kitty of interest. + function getKitty(uint256 _id) + external + view + returns ( + bool isGestating, + bool isReady, + uint256 cooldownIndex, + uint256 nextActionAt, + uint256 siringWithId, + uint256 birthTime, + uint256 matronId, + uint256 sireId, + uint256 generation, + uint256 genes + ) { + Kitty storage kit = kitties[_id]; + + // if this variable is 0 then it's not gestating + isGestating = (kit.siringWithId != 0); + isReady = (kit.cooldownEndBlock <= block.number); + cooldownIndex = uint256(kit.cooldownIndex); + nextActionAt = uint256(kit.cooldownEndBlock); + siringWithId = uint256(kit.siringWithId); + birthTime = uint256(kit.birthTime); + matronId = uint256(kit.matronId); + sireId = uint256(kit.sireId); + generation = uint256(kit.generation); + genes = kit.genes; + } + + /// @dev Override unpause so it requires all external contract addresses + /// to be set before contract can be unpaused. Also, we can't have + /// newContractAddress set either, because then the contract was upgraded. + /// @notice This is public rather than external so we can call super.unpause + /// without using an expensive CALL. + function unpause() public onlyCEO whenPaused { + require(saleAuction != address(0)); + require(siringAuction != address(0)); + require(geneScience != address(0)); + require(newContractAddress == address(0)); + + // Actually unpause the contract. + super.unpause(); + } + + // @dev Allows the CFO to capture the balance available to the contract. + function withdrawBalance() external onlyCFO { + uint256 balance = this.balance; + // Subtract all the currently pregnant kittens we have, plus 1 of margin. + uint256 subtractFees = (pregnantKitties + 1) * autoBirthFee; + + if (balance > subtractFees) { + cfoAddress.send(balance - subtractFees); + } + } +} \ No newline at end of file From 99c1fcdd10c8bb9734c70c07abd16135eb882974 Mon Sep 17 00:00:00 2001 From: rajeevgopalakrishna Date: Tue, 21 May 2019 15:24:28 +0530 Subject: [PATCH 028/223] Enables logging. --- .../slither_format/format_constable_states.py | 9 +- .../format_constant_function.py | 9 +- .../format_external_function.py | 7 +- .../format_naming_convention.py | 57 +- utils/slither_format/format_pragma.py | 11 +- utils/slither_format/format_solc_version.py | 9 +- utils/slither_format/slither_format.py | 37 +- .../tests/test_constable_states.py | 64 +- .../tests/test_constant_function.py | 56 +- .../tests/test_data/naming_convention.sol | 2 +- .../tests/test_detector_combinations.py | 34 +- .../tests/test_external_function.py | 70 +-- .../tests/test_naming_convention.py | 572 +++++++++--------- utils/slither_format/tests/test_pragma.py | 52 +- .../slither_format/tests/test_solc_version.py | 96 +-- .../tests/test_unused_state_vars.py | 24 +- 16 files changed, 562 insertions(+), 547 deletions(-) diff --git a/utils/slither_format/format_constable_states.py b/utils/slither_format/format_constable_states.py index fd3f8245f..0cf93b967 100644 --- a/utils/slither_format/format_constable_states.py +++ b/utils/slither_format/format_constable_states.py @@ -1,4 +1,9 @@ -import re +import re, logging +from slither.utils.colors import red, yellow, set_colorization_enabled + +logging.basicConfig(level=logging.INFO) +logger = logging.getLogger('Slither.Format') +set_colorization_enabled(True) class FormatConstableStates: @@ -21,5 +26,5 @@ class FormatConstableStates: "new_string" : new_str_of_interest }) else: - print("Error: State variable not found?!") + logger.error(red("State variable not found?!")) sys.exit(-1) diff --git a/utils/slither_format/format_constant_function.py b/utils/slither_format/format_constant_function.py index a737f8b1f..a4435e9ae 100644 --- a/utils/slither_format/format_constant_function.py +++ b/utils/slither_format/format_constant_function.py @@ -1,4 +1,9 @@ -import re +import re, logging +from slither.utils.colors import red, yellow, set_colorization_enabled + +logging.basicConfig(level=logging.INFO) +logger = logging.getLogger('Slither.Format') +set_colorization_enabled(True) class FormatConstantFunction: @@ -30,5 +35,5 @@ class FormatConstantFunction: "new_string" : replace_text }) else: - print("Error: No view/pure/constant specifier exists. Regex failed to remove specifier!") + logger.error(red("No view/pure/constant specifier exists. Regex failed to remove specifier!")) sys.exit(-1) diff --git a/utils/slither_format/format_external_function.py b/utils/slither_format/format_external_function.py index 36bf9f29e..5fffb9879 100644 --- a/utils/slither_format/format_external_function.py +++ b/utils/slither_format/format_external_function.py @@ -1,4 +1,9 @@ -import re +import re, logging +from slither.utils.colors import red, yellow, set_colorization_enabled + +logging.basicConfig(level=logging.INFO) +logger = logging.getLogger('Slither.Format') +set_colorization_enabled(True) class FormatExternalFunction: diff --git a/utils/slither_format/format_naming_convention.py b/utils/slither_format/format_naming_convention.py index 324deb165..1fffbb2c2 100644 --- a/utils/slither_format/format_naming_convention.py +++ b/utils/slither_format/format_naming_convention.py @@ -1,8 +1,13 @@ -import re, sys +import re, sys, logging from slither.core.expressions.identifier import Identifier from slither.core.cfg.node import Node from slither.slithir.operations import NewContract from slither.slithir.operations import Member +from slither.utils.colors import red, yellow, set_colorization_enabled + +logging.basicConfig(level=logging.INFO) +logger = logging.getLogger('Slither.Format') +set_colorization_enabled(True) class FormatNamingConvention: @@ -44,7 +49,7 @@ class FormatNamingConvention: FormatNamingConvention.create_patch_modifier_definition(slither, patches, name, contract_name, in_file, modify_loc_start, modify_loc_end) FormatNamingConvention.create_patch_modifier_uses(slither, patches, name, contract_name, in_file) else: - print("Unknown naming convention! " + _target) + logger.error(red("Unknown naming convention! " + _target)) sys.exit(-1) @staticmethod @@ -67,9 +72,7 @@ class FormatNamingConvention: if not patch in patches[in_file]: patches[in_file].append(patch) else: - print("Error: Could not find contract?!") - print("old_str_of_interest: " + old_str_of_interest) - print("Contract : " + name) + logger.error(red("Could not find contract?!")) sys.exit(-1) @staticmethod @@ -130,9 +133,7 @@ class FormatNamingConvention: if not patch in patches[in_file]: patches[in_file].append(patch) else: - print("Error: Could not find new object?!") - print("old_str_of_interest: " + old_str_of_interest) - print("Contract : " + name) + logger.error(red("Could not find new object?!")) sys.exit(-1) else: @@ -161,9 +162,7 @@ class FormatNamingConvention: if not patch in patches[in_file]: patches[in_file].append(patch) else: - print("Error: Could not find modifier?!") - print("old_str_of_interest: " + old_str_of_interest) - print("Modifier: " + name + " in Contract : " + contract_name) + logger.error(red("Could not find modifier?!")) sys.exit(-1) @staticmethod @@ -190,9 +189,7 @@ class FormatNamingConvention: if not patch in patches[in_file]: patches[in_file].append(patch) else: - print("Error: Could not find modifier name?!") - print("old_str_of_interest: " + old_str_of_interest) - print("Modifier: " + name + " in Contract : " + contract_name) + logger.error(red("Could not find modifier name?!")) sys.exit(-1) @staticmethod @@ -217,9 +214,7 @@ class FormatNamingConvention: if not patch in patches[in_file]: patches[in_file].append(patch) else: - print("Error: Could not find function?!") - print("old_str_of_interest: " + old_str_of_interest) - print("Function: " + name + " in Contract : " + contract_name) + logger.error(red("Could not find function?!")) sys.exit(-1) @staticmethod @@ -281,9 +276,7 @@ class FormatNamingConvention: if not patch in patches[in_file]: patches[in_file].append(patch) else: - print("Error: Could not find event?!") - print("old_str_of_interest: " + old_str_of_interest) - print("Event: " + name + " in Contract : " + contract_name) + logger.error(red("Could not find event?!")) sys.exit(-1) @staticmethod @@ -333,9 +326,7 @@ class FormatNamingConvention: if not patch in patches[in_file]: patches[in_file].append(patch) else: - print("Error: Could not find parameter declaration?!") - print("old_str_of_interest: " + old_str_of_interest) - print("Parameter: " + name + " of Function: " + function_name + " in Contract : " + contract_name) + logger.error(red("Could not find parameter declaration?!")) sys.exit(-1) @staticmethod @@ -367,9 +358,9 @@ class FormatNamingConvention: if not patch in patches[in_file]: patches[in_file].append(patch) else: - print("Error: Could not find parameter use?!") - print("old_str_of_interest: " + old_str_of_interest) - print("Parameter: " + name + " of Function: " + function_name + " in Contract : " + contract_name) + logger.error(red("Could not find parameter use?!")) + sys.exit(-1) + # Process function parameters passed to modifiers for modifier in function._expression_modifiers: for arg in modifier.arguments: @@ -391,9 +382,7 @@ class FormatNamingConvention: if not patch in patches[in_file]: patches[in_file].append(patch) else: - print("Error: Could not find parameter use in modifier?!") - print("old_str_of_interest: " + old_str_of_interest) - print("Parameter: " + name + " of Function: " + function_name + " in Contract : " + contract_name) + logger.error(red("Could not find parameter use in modifier?!")) sys.exit(-1) @staticmethod @@ -473,9 +462,7 @@ class FormatNamingConvention: if not patch in patches[in_file]: patches[in_file].append(patch) else: - print("Error: Could not find enum?!") - print("old_str_of_interest: " + old_str_of_interest) - print("Enum: " + name + " in Contract : " + contract_name) + logger.error(red("Could not find enum?!")) sys.exit(-1) @staticmethod @@ -542,8 +529,7 @@ t']:(node.source_mapping['start']+node.source_mapping['length'])].split('=')[0]) if not patch in patches[in_file]: patches[in_file].append(patch) else: - print("Error: Could not find new object?!") - print("Enum: " + name + " in Contract : " + contract_name) + logger.error(red("Could not find new object?!")) sys.exit(-1) # To-do: Check any other place/way where enum type is used @@ -567,8 +553,7 @@ t']:(node.source_mapping['start']+node.source_mapping['length'])].split('=')[0]) if not patch in patches[in_file]: patches[in_file].append(patch) else: - print("Error: Could not find struct?!") - print("Struct: " + name + " in Contract : " + contract_name) + logger.error(red("Could not find struct?!")) sys.exit(-1) @staticmethod diff --git a/utils/slither_format/format_pragma.py b/utils/slither_format/format_pragma.py index fc8fd2db7..29cc72285 100644 --- a/utils/slither_format/format_pragma.py +++ b/utils/slither_format/format_pragma.py @@ -1,4 +1,9 @@ -import re +import re, logging +from slither.utils.colors import red, yellow, set_colorization_enabled + +logging.basicConfig(level=logging.INFO) +logger = logging.getLogger('Slither.Format') +set_colorization_enabled(True) class FormatPragma: @@ -28,7 +33,7 @@ class FormatPragma: for version in used_solc_versions: replace_solc_versions.append(FormatPragma.determine_solc_version_replacement(version)) if not all(version == replace_solc_versions[0] for version in replace_solc_versions): - print("Multiple incompatible versions!") + logger.error(red("Multiple incompatible versions!")) sys.exit(-1) else: return replace_solc_versions[0] @@ -44,7 +49,7 @@ class FormatPragma: elif minor_version == '5': return "pragma solidity " + FormatPragma.REPLACEMENT_VERSIONS[1] + ';' else: - print("Unknown version!") + logger.error(red("Unknown version!")) sys.exit(-1) elif len(versions) == 2: version_left = versions[0] diff --git a/utils/slither_format/format_solc_version.py b/utils/slither_format/format_solc_version.py index de1fb2109..ae35d33b1 100644 --- a/utils/slither_format/format_solc_version.py +++ b/utils/slither_format/format_solc_version.py @@ -1,4 +1,9 @@ -import re +import re, logging +from slither.utils.colors import red, yellow, set_colorization_enabled + +logging.basicConfig(level=logging.INFO) +logger = logging.getLogger('Slither.Format') +set_colorization_enabled(True) class FormatSolcVersion: @@ -30,7 +35,7 @@ class FormatSolcVersion: elif minor_version == '5': return "pragma solidity " + FormatSolcVersion.REPLACEMENT_VERSIONS[1] + ';' else: - print("Unknown version!") + logger.error(red("Unknown version!")) sys.exit(-1) elif len(versions) == 2: version_left = versions[0] diff --git a/utils/slither_format/slither_format.py b/utils/slither_format/slither_format.py index df68e0e33..eb7e3cfe1 100644 --- a/utils/slither_format/slither_format.py +++ b/utils/slither_format/slither_format.py @@ -1,5 +1,6 @@ -import sys, re +import sys, re, logging from collections import defaultdict +from slither.utils.colors import red, yellow, 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 @@ -19,6 +20,10 @@ from slither_format.format_external_function import FormatExternalFunction from slither_format.format_constable_states import FormatConstableStates from slither_format.format_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, @@ -68,12 +73,12 @@ def sort_and_flag_overlapping_patches(patches): def is_overlap_patch(args, patch): if 'overlaps' in patch: if args.verbose_test: - print("Overlapping patch won't be applied!") - print("xDetector: " + patch['detector']) - print("xOld string: " + patch['old_string'].replace("\n","")) - print("xNew string: " + patch['new_string'].replace("\n","")) - print("xLocation start: " + str(patch['start'])) - print("xLocation end: " + str(patch['end'])) + 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 @@ -100,19 +105,19 @@ def apply_patches(slither, patches): out_file.close() def print_patches(number_of_slither_results, patches): - print("Number of Slither results: " + str(number_of_slither_results)) + 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]) - print("Number of patches: " + str(number_of_patches)) + logger.info("Number of patches: " + str(number_of_patches)) for file in patches: - print("Patch file: " + file) + logger.info("Patch file: " + file) for patch in patches[file]: - 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'])) + 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='') @@ -175,7 +180,7 @@ def apply_detector_results(slither, patches, detector_results): elif result['check'] == 'constant-function': FormatConstantFunction.format(slither, patches, result['elements']) else: - print("Not Supported Yet.") + logger.error(red("Not Supported Yet.")) sys.exit(-1) def get_number_of_slither_results (detector_results): diff --git a/utils/slither_format/tests/test_constable_states.py b/utils/slither_format/tests/test_constable_states.py index 6921485de..ade821b76 100644 --- a/utils/slither_format/tests/test_constable_states.py +++ b/utils/slither_format/tests/test_constable_states.py @@ -19,39 +19,39 @@ class TestConstableState(unittest.TestCase): p.wait() def test_constable_states(self): - outFD = open(self.testFilePath+".out","r") - outFD_lines = outFD.readlines() - for i in range(len(outFD_lines)): - outFD_lines[i] = outFD_lines[i].strip() + errFD = open(self.testFilePath+".err","r") + errFD_lines = errFD.readlines() + for i in range(len(errFD_lines)): + errFD_lines[i] = errFD_lines[i].strip() self.assertTrue(os.path.isfile(self.testFilePath+".format"),"Patched .format file is not created?!") - self.assertEqual(outFD_lines[0].rstrip(),"Number of Slither results: 6") - self.assertEqual(outFD_lines[1].rstrip(),"Number of patches: 6") - self.assertEqual(outFD_lines.count("Detector: constable-states"), 6) - self.assertEqual(outFD_lines.count("Old string: address public myFriendsAddress = 0xc0ffee254729296a45a3885639AC7E10F9d54979"), 1) - self.assertEqual(outFD_lines.count("New string: address public constant myFriendsAddress = 0xc0ffee254729296a45a3885639AC7E10F9d54979"), 1) - self.assertEqual(outFD_lines.count("Location start: 132"), 1) - self.assertEqual(outFD_lines.count("Location end: 208"), 1) - self.assertEqual(outFD_lines.count("Old string: uint public test = 5"), 1) - self.assertEqual(outFD_lines.count("New string: uint public constant test = 5"), 1) - self.assertEqual(outFD_lines.count("Location start: 237"), 1) - self.assertEqual(outFD_lines.count("Location end: 257"), 1) - self.assertEqual(outFD_lines.count("Old string: string text2 = \"xyz\""), 1) - self.assertEqual(outFD_lines.count("New string: string constant text2 = \"xyz\""), 1) - self.assertEqual(outFD_lines.count("Location start: 333"), 1) - self.assertEqual(outFD_lines.count("Location end: 353"), 1) - self.assertEqual(outFD_lines.count("Old string: address public mySistersAddress = 0x999999cf1046e68e36E1aA2E0E07105eDDD1f08E"), 1) - self.assertEqual(outFD_lines.count("New string: address public constant mySistersAddress = 0x999999cf1046e68e36E1aA2E0E07105eDDD1f08E"), 1) - self.assertEqual(outFD_lines.count("Location start: 496"), 1) - self.assertEqual(outFD_lines.count("Location end: 572"), 1) - self.assertEqual(outFD_lines.count("Old string: bytes32 should_be_constant = sha256('abc')"), 1) - self.assertEqual(outFD_lines.count("New string: bytes32 constant should_be_constant = sha256('abc')"), 1) - self.assertEqual(outFD_lines.count("Location start: 793"), 1) - self.assertEqual(outFD_lines.count("Location end: 835"), 1) - self.assertEqual(outFD_lines.count("Old string: uint should_be_constant_2 = A + 1"), 1) - self.assertEqual(outFD_lines.count("New string: uint constant should_be_constant_2 = A + 1"), 1) - self.assertEqual(outFD_lines.count("Location start: 841"), 1) - self.assertEqual(outFD_lines.count("Location end: 874"), 1) - outFD.close() + self.assertEqual(errFD_lines[0].rstrip(),"INFO:Slither.Format:Number of Slither results: 6") + self.assertEqual(errFD_lines[1].rstrip(),"INFO:Slither.Format:Number of patches: 6") + self.assertEqual(errFD_lines.count("INFO:Slither.Format:Detector: constable-states"), 6) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:Old string: address public myFriendsAddress = 0xc0ffee254729296a45a3885639AC7E10F9d54979"), 1) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:New string: address public constant myFriendsAddress = 0xc0ffee254729296a45a3885639AC7E10F9d54979"), 1) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:Location start: 132"), 1) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:Location end: 208"), 1) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:Old string: uint public test = 5"), 1) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:New string: uint public constant test = 5"), 1) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:Location start: 237"), 1) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:Location end: 257"), 1) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:Old string: string text2 = \"xyz\""), 1) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:New string: string constant text2 = \"xyz\""), 1) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:Location start: 333"), 1) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:Location end: 353"), 1) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:Old string: address public mySistersAddress = 0x999999cf1046e68e36E1aA2E0E07105eDDD1f08E"), 1) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:New string: address public constant mySistersAddress = 0x999999cf1046e68e36E1aA2E0E07105eDDD1f08E"), 1) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:Location start: 496"), 1) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:Location end: 572"), 1) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:Old string: bytes32 should_be_constant = sha256('abc')"), 1) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:New string: bytes32 constant should_be_constant = sha256('abc')"), 1) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:Location start: 793"), 1) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:Location end: 835"), 1) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:Old string: uint should_be_constant_2 = A + 1"), 1) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:New string: uint constant should_be_constant_2 = A + 1"), 1) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:Location start: 841"), 1) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:Location end: 874"), 1) + errFD.close() if __name__ == '__main__': unittest.main() diff --git a/utils/slither_format/tests/test_constant_function.py b/utils/slither_format/tests/test_constant_function.py index 8fe337726..9458545e6 100644 --- a/utils/slither_format/tests/test_constant_function.py +++ b/utils/slither_format/tests/test_constant_function.py @@ -29,37 +29,37 @@ class TestConstantFunctions(unittest.TestCase): p2.wait() def test_constant_function(self): - outFD1 = open(self.testFilePath1+".out","r") - outFD1_lines = outFD1.readlines() - for i in range(len(outFD1_lines)): - outFD1_lines[i] = outFD1_lines[i].strip() + errFD1 = open(self.testFilePath1+".err","r") + errFD1_lines = errFD1.readlines() + for i in range(len(errFD1_lines)): + errFD1_lines[i] = errFD1_lines[i].strip() self.assertTrue(os.path.isfile(self.testFilePath1+".format"),"Patched .format file is not created?!") - self.assertEqual(outFD1_lines[0],"Number of Slither results: 3") - self.assertEqual(outFD1_lines[1],"Number of patches: 3") - self.assertEqual(outFD1_lines.count("Detector: constant-function"), 3) - self.assertEqual(outFD1_lines.count("Old string: view"), 2) - self.assertEqual(outFD1_lines.count("Old string: constant"), 1) - self.assertEqual(outFD1_lines.count("New string:"), 3) - self.assertEqual(outFD1_lines.count("Location start: 77"), 1) - self.assertEqual(outFD1_lines.count("Location end: 81"), 1) - self.assertEqual(outFD1_lines.count("Location start: 149"), 1) - self.assertEqual(outFD1_lines.count("Location end: 157"), 1) - self.assertEqual(outFD1_lines.count("Location start: 360"), 1) - self.assertEqual(outFD1_lines.count("Location end: 364"), 1) - outFD1.close() + self.assertEqual(errFD1_lines[0],"INFO:Slither.Format:Number of Slither results: 3") + self.assertEqual(errFD1_lines[1],"INFO:Slither.Format:Number of patches: 3") + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Detector: constant-function"), 3) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Old string: view"), 2) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Old string: constant"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:New string:"), 3) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 77"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 81"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 149"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 157"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 360"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 364"), 1) + errFD1.close() - outFD2 = open(self.testFilePath2+".out","r") - outFD2_lines = outFD2.readlines() - for i in range(len(outFD2_lines)): - outFD2_lines[i] = outFD2_lines[i].strip() + errFD2 = open(self.testFilePath2+".err","r") + errFD2_lines = errFD2.readlines() + for i in range(len(errFD2_lines)): + errFD2_lines[i] = errFD2_lines[i].strip() self.assertTrue(os.path.isfile(self.testFilePath2+".format"),"Patched .format file is not created?!") - self.assertEqual(outFD2_lines[0],"Number of Slither results: 1") - self.assertEqual(outFD2_lines[1],"Number of patches: 1") - self.assertEqual(outFD2_lines.count("Old string: view"), 1) - self.assertEqual(outFD2_lines.count("New string:"), 1) - self.assertEqual(outFD2_lines.count("Location start: 221"), 1) - self.assertEqual(outFD2_lines.count("Location end: 225"), 1) - outFD2.close() + self.assertEqual(errFD2_lines[0],"INFO:Slither.Format:Number of Slither results: 1") + self.assertEqual(errFD2_lines[1],"INFO:Slither.Format:Number of patches: 1") + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Old string: view"), 1) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:New string:"), 1) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Location start: 221"), 1) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Location end: 225"), 1) + errFD2.close() if __name__ == '__main__': unittest.main() diff --git a/utils/slither_format/tests/test_data/naming_convention.sol b/utils/slither_format/tests/test_data/naming_convention.sol index 422788344..3420da1f1 100644 --- a/utils/slither_format/tests/test_data/naming_convention.sol +++ b/utils/slither_format/tests/test_data/naming_convention.sol @@ -1,4 +1,4 @@ -//pragma solidity ^0.4.24; +pragma solidity ^0.4.24; contract naming { diff --git a/utils/slither_format/tests/test_detector_combinations.py b/utils/slither_format/tests/test_detector_combinations.py index a521fec9a..c70f7e6b7 100644 --- a/utils/slither_format/tests/test_detector_combinations.py +++ b/utils/slither_format/tests/test_detector_combinations.py @@ -19,23 +19,23 @@ class TestDetectorCombinations(unittest.TestCase): p1.wait() def test_detector_combinations(self): - outFD1 = open(self.testFilePath1+".out","r") - outFD1_lines = outFD1.readlines() - outFD1.close() - for i in range(len(outFD1_lines)): - outFD1_lines[i] = outFD1_lines[i].strip() + errFD1 = open(self.testFilePath1+".err","r") + errFD1_lines = errFD1.readlines() + errFD1.close() + for i in range(len(errFD1_lines)): + errFD1_lines[i] = errFD1_lines[i].strip() self.assertTrue(os.path.isfile(self.testFilePath1+".format"),"Patched .format file is not created?!") - self.assertEqual(outFD1_lines.count("Number of Slither results: 12"), 1) - self.assertEqual(outFD1_lines.count("Number of patches: 19"), 1) - self.assertEqual(outFD1_lines.count("Overlapping patch won't be applied!"), 2) - self.assertEqual(outFD1_lines.count("xDetector: unused-state"), 1) - self.assertEqual(outFD1_lines.count("xDetector: constable-states"), 1) - self.assertEqual(outFD1_lines.count("Detector: naming-convention (state variable declaration)"), 2) - self.assertEqual(outFD1_lines.count("Detector: naming-convention (state variable uses)"), 3) - self.assertEqual(outFD1_lines.count("Detector: naming-convention (parameter declaration)"), 4) - self.assertEqual(outFD1_lines.count("Detector: naming-convention (parameter uses)"), 6) - self.assertEqual(outFD1_lines.count("Detector: external-function"), 2) - self.assertEqual(outFD1_lines.count("Detector: constant-function"), 1) - self.assertEqual(outFD1_lines.count("Detector: solc-version"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Number of Slither results: 12"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Number of patches: 19"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Overlapping patch won't be applied!"), 2) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:xDetector: unused-state"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:xDetector: constable-states"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Detector: naming-convention (state variable declaration)"), 2) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Detector: naming-convention (state variable uses)"), 3) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Detector: naming-convention (parameter declaration)"), 4) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Detector: naming-convention (parameter uses)"), 6) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Detector: external-function"), 2) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Detector: constant-function"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Detector: solc-version"), 1) if __name__ == '__main__': unittest.main() diff --git a/utils/slither_format/tests/test_external_function.py b/utils/slither_format/tests/test_external_function.py index 32ccdedef..1f3136114 100644 --- a/utils/slither_format/tests/test_external_function.py +++ b/utils/slither_format/tests/test_external_function.py @@ -29,44 +29,44 @@ class TestExternalFunctions(unittest.TestCase): p2.wait() def test_external_function(self): - outFD1 = open(self.testFilePath1+".out","r") - outFD1_lines = outFD1.readlines() - for i in range(len(outFD1_lines)): - outFD1_lines[i] = outFD1_lines[i].strip() + errFD1 = open(self.testFilePath1+".err","r") + errFD1_lines = errFD1.readlines() + for i in range(len(errFD1_lines)): + errFD1_lines[i] = errFD1_lines[i].strip() self.assertTrue(os.path.isfile(self.testFilePath1+".format"),"Patched .format file is not created?!") - self.assertEqual(outFD1_lines[0],"Number of Slither results: 9") - self.assertEqual(outFD1_lines[1],"Number of patches: 8") - self.assertEqual(outFD1_lines.count("Detector: external-function"), 8) - self.assertEqual(outFD1_lines.count("Old string: public"), 6) - self.assertEqual(outFD1_lines.count("New string: external"), 6) - self.assertEqual(outFD1_lines.count("Location start: 384"), 1) - self.assertEqual(outFD1_lines.count("Location end: 390"), 1) - self.assertEqual(outFD1_lines.count("Location start: 562"), 1) - self.assertEqual(outFD1_lines.count("Location end: 568"), 1) - self.assertEqual(outFD1_lines.count("Location start: 642"), 1) - self.assertEqual(outFD1_lines.count("Location end: 648"), 1) - self.assertEqual(outFD1_lines.count("Location start: 685"), 1) - self.assertEqual(outFD1_lines.count("Location end: 691"), 1) - self.assertEqual(outFD1_lines.count("Location start: 1022"), 1) - self.assertEqual(outFD1_lines.count("Location end: 1028"), 1) - self.assertEqual(outFD1_lines.count("Location start: 1305"), 1) - self.assertEqual(outFD1_lines.count("Location end: 1311"), 1) - self.assertEqual(outFD1_lines.count("Old string:"), 2) - self.assertEqual(outFD1_lines.count("New string: external"), 2) - self.assertEqual(outFD1_lines.count("Location start: 524"), 1) - self.assertEqual(outFD1_lines.count("Location end: 524"), 1) - self.assertEqual(outFD1_lines.count("Location start: 1142"), 1) - self.assertEqual(outFD1_lines.count("Location end: 1142"), 1) - outFD1.close() + self.assertEqual(errFD1_lines[0],"INFO:Slither.Format:Number of Slither results: 9") + self.assertEqual(errFD1_lines[1],"INFO:Slither.Format:Number of patches: 8") + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Detector: external-function"), 8) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Old string: public"), 6) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:New string: external"), 6) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 384"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 390"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 562"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 568"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 642"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 648"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 685"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 691"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 1022"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 1028"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 1305"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 1311"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Old string:"), 2) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:New string: external"), 2) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 524"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 524"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 1142"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 1142"), 1) + errFD1.close() - outFD2 = open(self.testFilePath2+".out","r") - outFD2_lines = outFD2.readlines() - for i in range(len(outFD2_lines)): - outFD2_lines[i] = outFD2_lines[i].strip() + errFD2 = open(self.testFilePath2+".err","r") + errFD2_lines = errFD2.readlines() + for i in range(len(errFD2_lines)): + errFD2_lines[i] = errFD2_lines[i].strip() self.assertFalse(os.path.isfile(self.testFilePath2+".format"),"Patched .format file _is_ created?!") - self.assertEqual(outFD2_lines[0],"Number of Slither results: 0") - self.assertEqual(outFD2_lines[1],"Number of patches: 0") - outFD2.close() + self.assertEqual(errFD2_lines[0],"INFO:Slither.Format:Number of Slither results: 0") + self.assertEqual(errFD2_lines[1],"INFO:Slither.Format:Number of patches: 0") + errFD2.close() if __name__ == '__main__': unittest.main() diff --git a/utils/slither_format/tests/test_naming_convention.py b/utils/slither_format/tests/test_naming_convention.py index 178676dca..310b53a0b 100644 --- a/utils/slither_format/tests/test_naming_convention.py +++ b/utils/slither_format/tests/test_naming_convention.py @@ -96,314 +96,314 @@ class TestNamingConvention(unittest.TestCase): p8.wait() def test_naming_convention_contract(self): - outFD1 = open(self.testFilePath1+".out","r") - outFD1_lines = outFD1.readlines() - outFD1.close() - for i in range(len(outFD1_lines)): - outFD1_lines[i] = outFD1_lines[i].strip() + errFD1 = open(self.testFilePath1+".err","r") + errFD1_lines = errFD1.readlines() + errFD1.close() + for i in range(len(errFD1_lines)): + errFD1_lines[i] = errFD1_lines[i].strip() self.assertTrue(os.path.isfile(self.testFilePath1+".format"),"Patched .format file is not created?!") - self.assertEqual(outFD1_lines[0],"Number of Slither results: 2") - self.assertEqual(outFD1_lines[1],"Number of patches: 10") - self.assertEqual(outFD1_lines.count("Detector: naming-convention (contract definition)"), 2) - self.assertEqual(outFD1_lines.count("Detector: naming-convention (contract state variable)"), 2) - self.assertEqual(outFD1_lines.count("Detector: naming-convention (contract function variable)"), 5) - self.assertEqual(outFD1_lines.count("Detector: naming-convention (contract new object)"), 1) - self.assertEqual(outFD1_lines.count("Old string: contract one"), 1) - self.assertEqual(outFD1_lines.count("New string: contract One"), 1) - self.assertEqual(outFD1_lines.count("Location start: 53"), 1) - self.assertEqual(outFD1_lines.count("Location end: 65"), 1) - self.assertEqual(outFD1_lines.count("Old string: three k"), 1) - self.assertEqual(outFD1_lines.count("New string: Three k"), 1) - self.assertEqual(outFD1_lines.count("Location start: 117"), 1) - self.assertEqual(outFD1_lines.count("Location end: 124"), 1) - self.assertEqual(outFD1_lines.count("Old string: three l"), 1) - self.assertEqual(outFD1_lines.count("New string: Three l"), 1) - self.assertEqual(outFD1_lines.count("Location start: 206"), 1) - self.assertEqual(outFD1_lines.count("Location end: 213"), 1) - self.assertEqual(outFD1_lines.count("Old string: one m"), 1) - self.assertEqual(outFD1_lines.count("New string: One m"), 1) - self.assertEqual(outFD1_lines.count("Location start: 343"), 1) - self.assertEqual(outFD1_lines.count("Location end: 348"), 1) - self.assertEqual(outFD1_lines.count("Old string: one n"), 1) - self.assertEqual(outFD1_lines.count("New string: One n"), 1) - self.assertEqual(outFD1_lines.count("Location start: 423"), 1) - self.assertEqual(outFD1_lines.count("Location end: 428"), 1) - self.assertEqual(outFD1_lines.count("Old string: contract three"), 1) - self.assertEqual(outFD1_lines.count("New string: contract Three"), 1) - self.assertEqual(outFD1_lines.count("Location start: 498"), 1) - self.assertEqual(outFD1_lines.count("Location end: 512"), 1) - self.assertEqual(outFD1_lines.count("Old string: one"), 1) - self.assertEqual(outFD1_lines.count("New string: One"), 1) - self.assertEqual(outFD1_lines.count("Location start: 646"), 1) - self.assertEqual(outFD1_lines.count("Location end: 649"), 1) - self.assertEqual(outFD1_lines.count("Old string: one r = new one()"), 1) - self.assertEqual(outFD1_lines.count("New string: One r = new one()"), 1) - self.assertEqual(outFD1_lines.count("Location start: 773"), 1) - self.assertEqual(outFD1_lines.count("Location end: 790"), 1) - self.assertEqual(outFD1_lines.count("Old string: one q"), 1) - self.assertEqual(outFD1_lines.count("New string: One q"), 1) - self.assertEqual(outFD1_lines.count("Location start: 871"), 1) - self.assertEqual(outFD1_lines.count("Location end: 876"), 1) - self.assertEqual(outFD1_lines.count("Old string: new one()"), 1) - self.assertEqual(outFD1_lines.count("New string: new One()"), 1) - self.assertEqual(outFD1_lines.count("Location start: 781"), 1) - self.assertEqual(outFD1_lines.count("Location end: 788"), 1) + self.assertEqual(errFD1_lines[0],"INFO:Slither.Format:Number of Slither results: 2") + self.assertEqual(errFD1_lines[1],"INFO:Slither.Format:Number of patches: 10") + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Detector: naming-convention (contract definition)"), 2) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Detector: naming-convention (contract state variable)"), 2) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Detector: naming-convention (contract function variable)"), 5) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Detector: naming-convention (contract new object)"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Old string: contract one"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:New string: contract One"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 53"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 65"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Old string: three k"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:New string: Three k"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 117"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 124"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Old string: three l"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:New string: Three l"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 206"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 213"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Old string: one m"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:New string: One m"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 343"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 348"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Old string: one n"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:New string: One n"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 423"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 428"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Old string: contract three"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:New string: contract Three"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 498"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 512"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Old string: one"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:New string: One"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 646"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 649"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Old string: one r = new one()"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:New string: One r = new one()"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 773"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 790"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Old string: one q"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:New string: One q"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 871"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 876"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Old string: new one()"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:New string: new One()"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 781"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 788"), 1) def test_naming_convention_modifier(self): - outFD2 = open(self.testFilePath2+".out","r") - outFD2_lines = outFD2.readlines() - outFD2.close() - for i in range(len(outFD2_lines)): - outFD2_lines[i] = outFD2_lines[i].strip() + errFD2 = open(self.testFilePath2+".err","r") + errFD2_lines = errFD2.readlines() + errFD2.close() + for i in range(len(errFD2_lines)): + errFD2_lines[i] = errFD2_lines[i].strip() self.assertTrue(os.path.isfile(self.testFilePath2+".format"),"Patched .format file is not created?!") - self.assertEqual(outFD2_lines[0],"Number of Slither results: 2") - self.assertEqual(outFD2_lines[1],"Number of patches: 5") - self.assertEqual(outFD2_lines.count("Detector: naming-convention (modifier definition)"), 2) - self.assertEqual(outFD2_lines.count("Detector: naming-convention (modifier uses)"), 3) - self.assertEqual(outFD2_lines.count("Old string: modifier One"), 1) - self.assertEqual(outFD2_lines.count("New string: modifier one"), 1) - self.assertEqual(outFD2_lines.count("Location start: 215"), 1) - self.assertEqual(outFD2_lines.count("Location end: 227"), 1) - self.assertEqual(outFD2_lines.count("Old string: () One"), 1) - self.assertEqual(outFD2_lines.count("New string: () one"), 1) - self.assertEqual(outFD2_lines.count("Location start: 288"), 1) - self.assertEqual(outFD2_lines.count("Location end: 295"), 1) - self.assertEqual(outFD2_lines.count("Old string: modifier Two"), 1) - self.assertEqual(outFD2_lines.count("New string: modifier two"), 1) - self.assertEqual(outFD2_lines.count("Location start: 423"), 1) - self.assertEqual(outFD2_lines.count("Location end: 435"), 1) - self.assertEqual(outFD2_lines.count("Old string: () one Two returns"), 2) - self.assertEqual(outFD2_lines.count("New string: () one two returns"), 2) - self.assertEqual(outFD2_lines.count("Location start: 503"), 1) - self.assertEqual(outFD2_lines.count("Location end: 522"), 1) - self.assertEqual(outFD2_lines.count("Location start: 718"), 1) - self.assertEqual(outFD2_lines.count("Location end: 737"), 1) + self.assertEqual(errFD2_lines[0],"INFO:Slither.Format:Number of Slither results: 2") + self.assertEqual(errFD2_lines[1],"INFO:Slither.Format:Number of patches: 5") + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Detector: naming-convention (modifier definition)"), 2) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Detector: naming-convention (modifier uses)"), 3) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Old string: modifier One"), 1) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:New string: modifier one"), 1) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Location start: 215"), 1) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Location end: 227"), 1) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Old string: () One"), 1) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:New string: () one"), 1) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Location start: 288"), 1) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Location end: 295"), 1) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Old string: modifier Two"), 1) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:New string: modifier two"), 1) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Location start: 423"), 1) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Location end: 435"), 1) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Old string: () one Two returns"), 2) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:New string: () one two returns"), 2) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Location start: 503"), 1) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Location end: 522"), 1) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Location start: 718"), 1) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Location end: 737"), 1) def test_naming_convention_structure(self): - outFD3 = open(self.testFilePath3+".out","r") - outFD3_lines = outFD3.readlines() - outFD3.close() - for i in range(len(outFD3_lines)): - outFD3_lines[i] = outFD3_lines[i].strip() + errFD3 = open(self.testFilePath3+".err","r") + errFD3_lines = errFD3.readlines() + errFD3.close() + for i in range(len(errFD3_lines)): + errFD3_lines[i] = errFD3_lines[i].strip() self.assertTrue(os.path.isfile(self.testFilePath3+".format"),"Patched .format file is not created?!") - self.assertEqual(outFD3_lines[0],"Number of Slither results: 2") - self.assertEqual(outFD3_lines[1],"Number of patches: 8") - self.assertEqual(outFD3_lines.count("Detector: naming-convention (struct definition)"), 2) - self.assertEqual(outFD3_lines.count("Detector: naming-convention (struct use)"), 6) - self.assertEqual(outFD3_lines.count("Old string: struct s { uint i; }"), 2) - self.assertEqual(outFD3_lines.count("New string: struct S { uint i; }"), 2) - self.assertEqual(outFD3_lines.count("Location start: 108"), 1) - self.assertEqual(outFD3_lines.count("Location end: 134"), 1) - self.assertEqual(outFD3_lines.count("Location start: 434"), 1) - self.assertEqual(outFD3_lines.count("Location end: 460"), 1) - self.assertEqual(outFD3_lines.count("Old string: s s1"), 2) - self.assertEqual(outFD3_lines.count("New string: S s1"), 2) - self.assertEqual(outFD3_lines.count("Location start: 171"), 1) - self.assertEqual(outFD3_lines.count("Location end: 175"), 1) - self.assertEqual(outFD3_lines.count("Location start: 497"), 1) - self.assertEqual(outFD3_lines.count("Location end: 501"), 1) - self.assertEqual(outFD3_lines.count("Old string: s sA"), 2) - self.assertEqual(outFD3_lines.count("New string: S sA"), 2) - self.assertEqual(outFD3_lines.count("Location start: 570"), 1) - self.assertEqual(outFD3_lines.count("Location end: 574"), 1) - self.assertEqual(outFD3_lines.count("Location start: 715"), 1) - self.assertEqual(outFD3_lines.count("Location end: 719"), 1) - self.assertEqual(outFD3_lines.count("Old string: s"), 2) - self.assertEqual(outFD3_lines.count("New string: S"), 2) - self.assertEqual(outFD3_lines.count("Location start: 585"), 1) - self.assertEqual(outFD3_lines.count("Location end: 586"), 1) - self.assertEqual(outFD3_lines.count("Location start: 730"), 1) - self.assertEqual(outFD3_lines.count("Location end: 731"), 1) + self.assertEqual(errFD3_lines[0],"INFO:Slither.Format:Number of Slither results: 2") + self.assertEqual(errFD3_lines[1],"INFO:Slither.Format:Number of patches: 8") + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Detector: naming-convention (struct definition)"), 2) + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Detector: naming-convention (struct use)"), 6) + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Old string: struct s { uint i; }"), 2) + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:New string: struct S { uint i; }"), 2) + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Location start: 108"), 1) + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Location end: 134"), 1) + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Location start: 434"), 1) + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Location end: 460"), 1) + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Old string: s s1"), 2) + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:New string: S s1"), 2) + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Location start: 171"), 1) + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Location end: 175"), 1) + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Location start: 497"), 1) + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Location end: 501"), 1) + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Old string: s sA"), 2) + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:New string: S sA"), 2) + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Location start: 570"), 1) + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Location end: 574"), 1) + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Location start: 715"), 1) + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Location end: 719"), 1) + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Old string: s"), 2) + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:New string: S"), 2) + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Location start: 585"), 1) + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Location end: 586"), 1) + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Location start: 730"), 1) + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Location end: 731"), 1) def test_naming_convention_enum(self): - outFD4 = open(self.testFilePath4+".out","r") - outFD4_lines = outFD4.readlines() - outFD4.close() - for i in range(len(outFD4_lines)): - outFD4_lines[i] = outFD4_lines[i].strip() + errFD4 = open(self.testFilePath4+".err","r") + errFD4_lines = errFD4.readlines() + errFD4.close() + for i in range(len(errFD4_lines)): + errFD4_lines[i] = errFD4_lines[i].strip() self.assertTrue(os.path.isfile(self.testFilePath4+".format"),"Patched .format file is not created?!") - self.assertEqual(outFD4_lines[0],"Number of Slither results: 2") - self.assertEqual(outFD4_lines[1],"Number of patches: 11") - self.assertEqual(outFD4_lines.count("Detector: naming-convention (enum definition)"), 2) - self.assertEqual(outFD4_lines.count("Detector: naming-convention (enum use)"), 9) - self.assertEqual(outFD4_lines.count("Old string: enum e {ONE, TWO}"), 2) - self.assertEqual(outFD4_lines.count("New string: enum E {ONE, TWO}"), 2) - self.assertEqual(outFD4_lines.count("Location start: 73"), 1) - self.assertEqual(outFD4_lines.count("Location end: 90"), 1) - self.assertEqual(outFD4_lines.count("Location start: 426"), 1) - self.assertEqual(outFD4_lines.count("Location end: 443"), 1) - self.assertEqual(outFD4_lines.count("Old string: e e1"), 2) - self.assertEqual(outFD4_lines.count("New string: E e1"), 2) - self.assertEqual(outFD4_lines.count("Location start: 125"), 1) - self.assertEqual(outFD4_lines.count("Location end: 129"), 1) - self.assertEqual(outFD4_lines.count("Location start: 478"), 1) - self.assertEqual(outFD4_lines.count("Location end: 482"), 1) - self.assertEqual(outFD4_lines.count("Old string: e eA"), 2) - self.assertEqual(outFD4_lines.count("New string: E eA"), 2) - self.assertEqual(outFD4_lines.count("Location start: 549"), 1) - self.assertEqual(outFD4_lines.count("Location end: 553"), 1) - self.assertEqual(outFD4_lines.count("Location start: 690"), 1) - self.assertEqual(outFD4_lines.count("Location end: 694"), 1) - self.assertEqual(outFD4_lines.count("Old string: e e2 = eA"), 2) - self.assertEqual(outFD4_lines.count("New string: E e2 = eA"), 2) - self.assertEqual(outFD4_lines.count("Location start: 573"), 1) - self.assertEqual(outFD4_lines.count("Location end: 582"), 1) - self.assertEqual(outFD4_lines.count("Location start: 714"), 1) - self.assertEqual(outFD4_lines.count("Location end: 723"), 1) - self.assertEqual(outFD4_lines.count("Old string: e.ONE"), 1) - self.assertEqual(outFD4_lines.count("New string: E.ONE"), 1) - self.assertEqual(outFD4_lines.count("Location start: 186"), 1) - self.assertEqual(outFD4_lines.count("Location end: 192"), 1) - self.assertEqual(outFD4_lines.count("Old string: e"), 2) - self.assertEqual(outFD4_lines.count("New string: E"), 2) - self.assertEqual(outFD4_lines.count("Location start: 564"), 1) - self.assertEqual(outFD4_lines.count("Location end: 565"), 1) - self.assertEqual(outFD4_lines.count("Location start: 705"), 1) - self.assertEqual(outFD4_lines.count("Location end: 706"), 1) + self.assertEqual(errFD4_lines[0],"INFO:Slither.Format:Number of Slither results: 2") + self.assertEqual(errFD4_lines[1],"INFO:Slither.Format:Number of patches: 11") + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Detector: naming-convention (enum definition)"), 2) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Detector: naming-convention (enum use)"), 9) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Old string: enum e {ONE, TWO}"), 2) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:New string: enum E {ONE, TWO}"), 2) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location start: 73"), 1) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location end: 90"), 1) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location start: 426"), 1) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location end: 443"), 1) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Old string: e e1"), 2) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:New string: E e1"), 2) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location start: 125"), 1) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location end: 129"), 1) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location start: 478"), 1) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location end: 482"), 1) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Old string: e eA"), 2) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:New string: E eA"), 2) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location start: 549"), 1) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location end: 553"), 1) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location start: 690"), 1) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location end: 694"), 1) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Old string: e e2 = eA"), 2) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:New string: E e2 = eA"), 2) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location start: 573"), 1) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location end: 582"), 1) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location start: 714"), 1) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location end: 723"), 1) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Old string: e.ONE"), 1) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:New string: E.ONE"), 1) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location start: 186"), 1) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location end: 192"), 1) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Old string: e"), 2) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:New string: E"), 2) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location start: 564"), 1) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location end: 565"), 1) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location start: 705"), 1) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location end: 706"), 1) def test_naming_convention_event(self): - outFD5 = open(self.testFilePath5+".out","r") - outFD5_lines = outFD5.readlines() - outFD5.close() - for i in range(len(outFD5_lines)): - outFD5_lines[i] = outFD5_lines[i].strip() + errFD5 = open(self.testFilePath5+".err","r") + errFD5_lines = errFD5.readlines() + errFD5.close() + for i in range(len(errFD5_lines)): + errFD5_lines[i] = errFD5_lines[i].strip() self.assertTrue(os.path.isfile(self.testFilePath5+".format"),"Patched .format file is not created?!") - self.assertEqual(outFD5_lines[0],"Number of Slither results: 2") - self.assertEqual(outFD5_lines[1],"Number of patches: 5") - self.assertEqual(outFD5_lines.count("Detector: naming-convention (event definition)"), 2) - self.assertEqual(outFD5_lines.count("Detector: naming-convention (event calls)"), 3) - self.assertEqual(outFD5_lines.count("Old string: event e(uint);"), 2) - self.assertEqual(outFD5_lines.count("New string: event E(uint);"), 2) - self.assertEqual(outFD5_lines.count("Location start: 75"), 1) - self.assertEqual(outFD5_lines.count("Location end: 89"), 1) - self.assertEqual(outFD5_lines.count("Location start: 148"), 1) - self.assertEqual(outFD5_lines.count("Location end: 152"), 1) - self.assertEqual(outFD5_lines.count("Old string: e(i)"), 3) - self.assertEqual(outFD5_lines.count("New string: E(i)"), 3) - self.assertEqual(outFD5_lines.count("Location start: 148"), 1) - self.assertEqual(outFD5_lines.count("Location end: 152"), 1) - self.assertEqual(outFD5_lines.count("Location start: 438"), 1) - self.assertEqual(outFD5_lines.count("Location end: 442"), 1) - self.assertEqual(outFD5_lines.count("Location start: 550"), 1) - self.assertEqual(outFD5_lines.count("Location end: 554"), 1) + self.assertEqual(errFD5_lines[0],"INFO:Slither.Format:Number of Slither results: 2") + self.assertEqual(errFD5_lines[1],"INFO:Slither.Format:Number of patches: 5") + self.assertEqual(errFD5_lines.count("INFO:Slither.Format:Detector: naming-convention (event definition)"), 2) + self.assertEqual(errFD5_lines.count("INFO:Slither.Format:Detector: naming-convention (event calls)"), 3) + self.assertEqual(errFD5_lines.count("INFO:Slither.Format:Old string: event e(uint);"), 2) + self.assertEqual(errFD5_lines.count("INFO:Slither.Format:New string: event E(uint);"), 2) + self.assertEqual(errFD5_lines.count("INFO:Slither.Format:Location start: 75"), 1) + self.assertEqual(errFD5_lines.count("INFO:Slither.Format:Location end: 89"), 1) + self.assertEqual(errFD5_lines.count("INFO:Slither.Format:Location start: 148"), 1) + self.assertEqual(errFD5_lines.count("INFO:Slither.Format:Location end: 152"), 1) + self.assertEqual(errFD5_lines.count("INFO:Slither.Format:Old string: e(i)"), 3) + self.assertEqual(errFD5_lines.count("INFO:Slither.Format:New string: E(i)"), 3) + self.assertEqual(errFD5_lines.count("INFO:Slither.Format:Location start: 148"), 1) + self.assertEqual(errFD5_lines.count("INFO:Slither.Format:Location end: 152"), 1) + self.assertEqual(errFD5_lines.count("INFO:Slither.Format:Location start: 438"), 1) + self.assertEqual(errFD5_lines.count("INFO:Slither.Format:Location end: 442"), 1) + self.assertEqual(errFD5_lines.count("INFO:Slither.Format:Location start: 550"), 1) + self.assertEqual(errFD5_lines.count("INFO:Slither.Format:Location end: 554"), 1) def test_naming_convention_function(self): - outFD6 = open(self.testFilePath6+".out","r") - outFD6_lines = outFD6.readlines() - outFD6.close() - for i in range(len(outFD6_lines)): - outFD6_lines[i] = outFD6_lines[i].strip() + errFD6 = open(self.testFilePath6+".err","r") + errFD6_lines = errFD6.readlines() + errFD6.close() + for i in range(len(errFD6_lines)): + errFD6_lines[i] = errFD6_lines[i].strip() self.assertTrue(os.path.isfile(self.testFilePath6+".format"),"Patched .format file is not created?!") - self.assertEqual(outFD6_lines[0],"Number of Slither results: 2") - self.assertEqual(outFD6_lines[1],"Number of patches: 4") - self.assertEqual(outFD6_lines.count("Detector: naming-convention (function definition)"), 2) - self.assertEqual(outFD6_lines.count("Detector: naming-convention (function calls)"), 2) - self.assertEqual(outFD6_lines.count("Old string: function Foo"), 1) - self.assertEqual(outFD6_lines.count("New string: function foo"), 1) - self.assertEqual(outFD6_lines.count("Location start: 76"), 1) - self.assertEqual(outFD6_lines.count("Location end: 88"), 1) - self.assertEqual(outFD6_lines.count("Old string: function Foobar"), 1) - self.assertEqual(outFD6_lines.count("New string: function foobar"), 1) - self.assertEqual(outFD6_lines.count("Location start: 189"), 1) - self.assertEqual(outFD6_lines.count("Location end: 204"), 1) - self.assertEqual(outFD6_lines.count("Old string: Foobar(10)"), 1) - self.assertEqual(outFD6_lines.count("New string: foobar(10)"), 1) - self.assertEqual(outFD6_lines.count("Location start: 136"), 1) - self.assertEqual(outFD6_lines.count("Location end: 146"), 1) - self.assertEqual(outFD6_lines.count("Old string: a.Foobar(10)"), 1) - self.assertEqual(outFD6_lines.count("New string: a.foobar(10)"), 1) - self.assertEqual(outFD6_lines.count("Location start: 516"), 1) - self.assertEqual(outFD6_lines.count("Location end: 528"), 1) + self.assertEqual(errFD6_lines[0],"INFO:Slither.Format:Number of Slither results: 2") + self.assertEqual(errFD6_lines[1],"INFO:Slither.Format:Number of patches: 4") + self.assertEqual(errFD6_lines.count("INFO:Slither.Format:Detector: naming-convention (function definition)"), 2) + self.assertEqual(errFD6_lines.count("INFO:Slither.Format:Detector: naming-convention (function calls)"), 2) + self.assertEqual(errFD6_lines.count("INFO:Slither.Format:Old string: function Foo"), 1) + self.assertEqual(errFD6_lines.count("INFO:Slither.Format:New string: function foo"), 1) + self.assertEqual(errFD6_lines.count("INFO:Slither.Format:Location start: 76"), 1) + self.assertEqual(errFD6_lines.count("INFO:Slither.Format:Location end: 88"), 1) + self.assertEqual(errFD6_lines.count("INFO:Slither.Format:Old string: function Foobar"), 1) + self.assertEqual(errFD6_lines.count("INFO:Slither.Format:New string: function foobar"), 1) + self.assertEqual(errFD6_lines.count("INFO:Slither.Format:Location start: 189"), 1) + self.assertEqual(errFD6_lines.count("INFO:Slither.Format:Location end: 204"), 1) + self.assertEqual(errFD6_lines.count("INFO:Slither.Format:Old string: Foobar(10)"), 1) + self.assertEqual(errFD6_lines.count("INFO:Slither.Format:New string: foobar(10)"), 1) + self.assertEqual(errFD6_lines.count("INFO:Slither.Format:Location start: 136"), 1) + self.assertEqual(errFD6_lines.count("INFO:Slither.Format:Location end: 146"), 1) + self.assertEqual(errFD6_lines.count("INFO:Slither.Format:Old string: a.Foobar(10)"), 1) + self.assertEqual(errFD6_lines.count("INFO:Slither.Format:New string: a.foobar(10)"), 1) + self.assertEqual(errFD6_lines.count("INFO:Slither.Format:Location start: 516"), 1) + self.assertEqual(errFD6_lines.count("INFO:Slither.Format:Location end: 528"), 1) def test_naming_convention_parameter(self): - outFD7 = open(self.testFilePath7+".out","r") - outFD7_lines = outFD7.readlines() - outFD7.close() - for i in range(len(outFD7_lines)): - outFD7_lines[i] = outFD7_lines[i].strip() + errFD7 = open(self.testFilePath7+".err","r") + errFD7_lines = errFD7.readlines() + errFD7.close() + for i in range(len(errFD7_lines)): + errFD7_lines[i] = errFD7_lines[i].strip() self.assertTrue(os.path.isfile(self.testFilePath7+".format"),"Patched .format file is not created?!") - self.assertEqual(outFD7_lines[0],"Number of Slither results: 6") - self.assertEqual(outFD7_lines[1],"Number of patches: 12") - self.assertEqual(outFD7_lines.count("Detector: naming-convention (parameter declaration)"), 6) - self.assertEqual(outFD7_lines.count("Detector: naming-convention (parameter uses)"), 6) - self.assertEqual(outFD7_lines.count("Old string: uint Count"), 3) - self.assertEqual(outFD7_lines.count("New string: uint _Count"), 3) - self.assertEqual(outFD7_lines.count("Location start: 91"), 1) - self.assertEqual(outFD7_lines.count("Location end: 101"), 1) - self.assertEqual(outFD7_lines.count("Location start: 215"), 1) - self.assertEqual(outFD7_lines.count("Location end: 225"), 1) - self.assertEqual(outFD7_lines.count("Old string: Count"), 3) - self.assertEqual(outFD7_lines.count("New string: _Count"), 3) - self.assertEqual(outFD7_lines.count("Location start: 148"), 1) - self.assertEqual(outFD7_lines.count("Location end: 153"), 1) - self.assertEqual(outFD7_lines.count("Location start: 308"), 1) - self.assertEqual(outFD7_lines.count("Location end: 313"), 1) - self.assertEqual(outFD7_lines.count("Location start: 489"), 1) - self.assertEqual(outFD7_lines.count("Location end: 499"), 1) - self.assertEqual(outFD7_lines.count("Location start: 580"), 1) - self.assertEqual(outFD7_lines.count("Location end: 585"), 1) - self.assertEqual(outFD7_lines.count("Old string: Count)"), 1) - self.assertEqual(outFD7_lines.count("New string: _Count)"), 1) - self.assertEqual(outFD7_lines.count("Location start: 506"), 1) - self.assertEqual(outFD7_lines.count("Location end: 512"), 1) - self.assertEqual(outFD7_lines.count("Old string: uint Number"), 1) - self.assertEqual(outFD7_lines.count("New string: uint _Number"), 1) - self.assertEqual(outFD7_lines.count("Location start: 227"), 1) - self.assertEqual(outFD7_lines.count("Location end: 238"), 1) - self.assertEqual(outFD7_lines.count("Old string: Number"), 1) - self.assertEqual(outFD7_lines.count("New string: _Number"), 1) - self.assertEqual(outFD7_lines.count("Location start: 314"), 1) - self.assertEqual(outFD7_lines.count("Location end: 320"), 1) - self.assertEqual(outFD7_lines.count("Old string: address _to"), 1) - self.assertEqual(outFD7_lines.count("New string: address _To"), 1) - self.assertEqual(outFD7_lines.count("Location start: 708"), 1) - self.assertEqual(outFD7_lines.count("Location end: 719"), 1) - self.assertEqual(outFD7_lines.count("Old string: address _from"), 1) - self.assertEqual(outFD7_lines.count("New string: address _From"), 1) - self.assertEqual(outFD7_lines.count("Location start: 721"), 1) - self.assertEqual(outFD7_lines.count("Location end: 734"), 1) - self.assertEqual(outFD7_lines.count("Old string: _to"), 1) - self.assertEqual(outFD7_lines.count("New string: _To"), 1) - self.assertEqual(outFD7_lines.count("Location start: 811"), 1) - self.assertEqual(outFD7_lines.count("Location end: 814"), 1) - self.assertEqual(outFD7_lines.count("Old string: _from"), 1, "Index variables of writes are not captured by node._expression_vars_read of Slither") - self.assertEqual(outFD7_lines.count("New string: _From"), 1) + self.assertEqual(errFD7_lines[0],"INFO:Slither.Format:Number of Slither results: 6") + self.assertEqual(errFD7_lines[1],"INFO:Slither.Format:Number of patches: 12") + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Detector: naming-convention (parameter declaration)"), 6) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Detector: naming-convention (parameter uses)"), 6) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Old string: uint Count"), 3) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:New string: uint _Count"), 3) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location start: 91"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location end: 101"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location start: 215"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location end: 225"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Old string: Count"), 3) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:New string: _Count"), 3) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location start: 148"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location end: 153"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location start: 308"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location end: 313"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location start: 489"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location end: 499"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location start: 580"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location end: 585"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Old string: Count)"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:New string: _Count)"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location start: 506"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location end: 512"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Old string: uint Number"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:New string: uint _Number"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location start: 227"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location end: 238"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Old string: Number"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:New string: _Number"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location start: 314"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location end: 320"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Old string: address _to"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:New string: address _To"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location start: 708"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location end: 719"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Old string: address _from"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:New string: address _From"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location start: 721"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location end: 734"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Old string: _to"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:New string: _To"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location start: 811"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location end: 814"), 1) + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Old string: _from"), 1, "Index variables of writes are not captured by node._expression_vars_read of Slither") + self.assertEqual(errFD7_lines.count("INFO:Slither.Format:New string: _From"), 1) def test_naming_convention_state_variable(self): - outFD8 = open(self.testFilePath8+".out","r") - outFD8_lines = outFD8.readlines() - outFD8.close() - for i in range(len(outFD8_lines)): - outFD8_lines[i] = outFD8_lines[i].strip() + errFD8 = open(self.testFilePath8+".err","r") + errFD8_lines = errFD8.readlines() + errFD8.close() + for i in range(len(errFD8_lines)): + errFD8_lines[i] = errFD8_lines[i].strip() self.assertTrue(os.path.isfile(self.testFilePath8+".format"),"Patched .format file is not created?!") - self.assertEqual(outFD8_lines[0],"Number of Slither results: 3") - self.assertEqual(outFD8_lines[1],"Number of patches: 9") - self.assertEqual(outFD8_lines.count("Detector: naming-convention (state variable declaration)"), 3) - self.assertEqual(outFD8_lines.count("Detector: naming-convention (state variable uses)"), 6) - self.assertEqual(outFD8_lines.count("Old string: number"), 3) - self.assertEqual(outFD8_lines.count("New string: NUMBER"), 3) - self.assertEqual(outFD8_lines.count("Location start: 469"), 1) - self.assertEqual(outFD8_lines.count("Location end: 475"), 1) - self.assertEqual(outFD8_lines.count("Location start: 716"), 1) - self.assertEqual(outFD8_lines.count("Location end: 722"), 1) - self.assertEqual(outFD8_lines.count("Location start: 850"), 1) - self.assertEqual(outFD8_lines.count("Location end: 856"), 1) - self.assertEqual(outFD8_lines.count("Old string: Count"), 3) - self.assertEqual(outFD8_lines.count("New string: count"), 3) - self.assertEqual(outFD8_lines.count("Location start: 547"), 1) - self.assertEqual(outFD8_lines.count("Location end: 552"), 1) - self.assertEqual(outFD8_lines.count("Location start: 725"), 1) - self.assertEqual(outFD8_lines.count("Location end: 730"), 1) - self.assertEqual(outFD8_lines.count("Location start: 745"), 1) - self.assertEqual(outFD8_lines.count("Location end: 750"), 1) - self.assertEqual(outFD8_lines.count("Old string: Maxnum"), 3) - self.assertEqual(outFD8_lines.count("New string: maxnum"), 3) - self.assertEqual(outFD8_lines.count("Location start: 634"), 1) - self.assertEqual(outFD8_lines.count("Location end: 640"), 1) - self.assertEqual(outFD8_lines.count("Location start: 733"), 1) - self.assertEqual(outFD8_lines.count("Location end: 739"), 1) - self.assertEqual(outFD8_lines.count("Location start: 859"), 1) - self.assertEqual(outFD8_lines.count("Location end: 865"), 1) + self.assertEqual(errFD8_lines[0],"INFO:Slither.Format:Number of Slither results: 3") + self.assertEqual(errFD8_lines[1],"INFO:Slither.Format:Number of patches: 9") + self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Detector: naming-convention (state variable declaration)"), 3) + self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Detector: naming-convention (state variable uses)"), 6) + self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Old string: number"), 3) + self.assertEqual(errFD8_lines.count("INFO:Slither.Format:New string: NUMBER"), 3) + self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Location start: 469"), 1) + self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Location end: 475"), 1) + self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Location start: 716"), 1) + self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Location end: 722"), 1) + self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Location start: 850"), 1) + self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Location end: 856"), 1) + self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Old string: Count"), 3) + self.assertEqual(errFD8_lines.count("INFO:Slither.Format:New string: count"), 3) + self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Location start: 547"), 1) + self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Location end: 552"), 1) + self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Location start: 725"), 1) + self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Location end: 730"), 1) + self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Location start: 745"), 1) + self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Location end: 750"), 1) + self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Old string: Maxnum"), 3) + self.assertEqual(errFD8_lines.count("INFO:Slither.Format:New string: maxnum"), 3) + self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Location start: 634"), 1) + self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Location end: 640"), 1) + self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Location start: 733"), 1) + self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Location end: 739"), 1) + self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Location start: 859"), 1) + self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Location end: 865"), 1) if __name__ == '__main__': unittest.main() diff --git a/utils/slither_format/tests/test_pragma.py b/utils/slither_format/tests/test_pragma.py index ea9ec60b4..70e0b7194 100644 --- a/utils/slither_format/tests/test_pragma.py +++ b/utils/slither_format/tests/test_pragma.py @@ -37,35 +37,35 @@ class TestPragma(unittest.TestCase): p2.wait() def test_pragma(self): - outFD1 = open(self.testFilePath1+".out","r") - outFD1_lines = outFD1.readlines() - for i in range(len(outFD1_lines)): - outFD1_lines[i] = outFD1_lines[i].strip() + errFD1 = open(self.testFilePath1+".err","r") + errFD1_lines = errFD1.readlines() + for i in range(len(errFD1_lines)): + errFD1_lines[i] = errFD1_lines[i].strip() self.assertTrue(os.path.isfile(self.testFilePath1+".format"),"Patched .format file is not created?!") - self.assertEqual(outFD1_lines[0],"Number of Slither results: 2") - self.assertEqual(outFD1_lines[1],"Number of patches: 2") - self.assertEqual(outFD1_lines.count("Detector: pragma"), 2) - self.assertEqual(outFD1_lines.count("Old string: pragma solidity ^0.4.23;"), 1) - self.assertEqual(outFD1_lines.count("Old string: pragma solidity ^0.4.24;"), 1) - self.assertEqual(outFD1_lines.count("New string: pragma solidity 0.4.25;"), 2) - self.assertEqual(outFD1_lines.count("Location start: 0"), 2) - self.assertEqual(outFD1_lines.count("Location end: 24"), 2) - outFD1.close() + self.assertEqual(errFD1_lines[0],"INFO:Slither.Format:Number of Slither results: 2") + self.assertEqual(errFD1_lines[1],"INFO:Slither.Format:Number of patches: 2") + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Detector: pragma"), 2) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Old string: pragma solidity ^0.4.23;"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Old string: pragma solidity ^0.4.24;"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:New string: pragma solidity 0.4.25;"), 2) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 0"), 2) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 24"), 2) + errFD1.close() - outFD2 = open(self.testFilePath2+".out","r") - outFD2_lines = outFD2.readlines() - for i in range(len(outFD2_lines)): - outFD2_lines[i] = outFD2_lines[i].strip() + errFD2 = open(self.testFilePath2+".err","r") + errFD2_lines = errFD2.readlines() + for i in range(len(errFD2_lines)): + errFD2_lines[i] = errFD2_lines[i].strip() self.assertTrue(os.path.isfile(self.testFilePath2+".format"),"Patched .format file is not created?!") - self.assertEqual(outFD2_lines[0],"Number of Slither results: 2") - self.assertEqual(outFD2_lines[1],"Number of patches: 2") - self.assertEqual(outFD2_lines.count("Detector: pragma"), 2) - self.assertEqual(outFD2_lines.count("Old string: pragma solidity ^0.5.4;"), 1) - self.assertEqual(outFD2_lines.count("Old string: pragma solidity ^0.5.2;"), 1) - self.assertEqual(outFD2_lines.count("New string: pragma solidity 0.5.3;"), 2) - self.assertEqual(outFD2_lines.count("Location start: 0"), 2) - self.assertEqual(outFD2_lines.count("Location end: 23"), 2) - outFD2.close() + self.assertEqual(errFD2_lines[0],"INFO:Slither.Format:Number of Slither results: 2") + self.assertEqual(errFD2_lines[1],"INFO:Slither.Format:Number of patches: 2") + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Detector: pragma"), 2) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Old string: pragma solidity ^0.5.4;"), 1) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Old string: pragma solidity ^0.5.2;"), 1) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:New string: pragma solidity 0.5.3;"), 2) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Location start: 0"), 2) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Location end: 23"), 2) + errFD2.close() if __name__ == '__main__': unittest.main() diff --git a/utils/slither_format/tests/test_solc_version.py b/utils/slither_format/tests/test_solc_version.py index 16a9ea34a..45b51d95c 100644 --- a/utils/slither_format/tests/test_solc_version.py +++ b/utils/slither_format/tests/test_solc_version.py @@ -54,61 +54,61 @@ class TestSolcVersion(unittest.TestCase): p4.wait() def test_solc_version(self): - outFD1 = open(self.testFilePath1+".out","r") - outFD1_lines = outFD1.readlines() - for i in range(len(outFD1_lines)): - outFD1_lines[i] = outFD1_lines[i].strip() + errFD1 = open(self.testFilePath1+".err","r") + errFD1_lines = errFD1.readlines() + for i in range(len(errFD1_lines)): + errFD1_lines[i] = errFD1_lines[i].strip() self.assertTrue(os.path.isfile(self.testFilePath1+".format"),"Patched .format file is not created?!") - self.assertEqual(outFD1_lines[0],"Number of Slither results: 1") - self.assertEqual(outFD1_lines[1],"Number of patches: 1") - self.assertEqual(outFD1_lines.count("Detector: solc-version"), 1) - self.assertEqual(outFD1_lines.count("Old string: pragma solidity ^0.4.23;"), 1) - self.assertEqual(outFD1_lines.count("New string: pragma solidity 0.4.25;"), 1) - self.assertEqual(outFD1_lines.count("Location start: 63"), 1) - self.assertEqual(outFD1_lines.count("Location end: 87"), 1) - outFD1.close() + self.assertEqual(errFD1_lines[0],"INFO:Slither.Format:Number of Slither results: 1") + self.assertEqual(errFD1_lines[1],"INFO:Slither.Format:Number of patches: 1") + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Detector: solc-version"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Old string: pragma solidity ^0.4.23;"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:New string: pragma solidity 0.4.25;"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 63"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 87"), 1) + errFD1.close() - outFD2 = open(self.testFilePath2+".out","r") - outFD2_lines = outFD2.readlines() - for i in range(len(outFD2_lines)): - outFD2_lines[i] = outFD2_lines[i].strip() + errFD2 = open(self.testFilePath2+".err","r") + errFD2_lines = errFD2.readlines() + for i in range(len(errFD2_lines)): + errFD2_lines[i] = errFD2_lines[i].strip() self.assertTrue(os.path.isfile(self.testFilePath2+".format"),"Patched .format file is not created?!") - self.assertEqual(outFD2_lines[0],"Number of Slither results: 1") - self.assertEqual(outFD2_lines[1],"Number of patches: 1") - self.assertEqual(outFD2_lines.count("Detector: solc-version"), 1) - self.assertEqual(outFD2_lines.count("Old string: pragma solidity >=0.4.0 <0.6.0;"), 1) - self.assertEqual(outFD2_lines.count("New string: pragma solidity 0.5.3;"), 1) - self.assertEqual(outFD2_lines.count("Location start: 63"), 1) - self.assertEqual(outFD2_lines.count("Location end: 94"), 1) - outFD2.close() + self.assertEqual(errFD2_lines[0],"INFO:Slither.Format:Number of Slither results: 1") + self.assertEqual(errFD2_lines[1],"INFO:Slither.Format:Number of patches: 1") + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Detector: solc-version"), 1) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Old string: pragma solidity >=0.4.0 <0.6.0;"), 1) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:New string: pragma solidity 0.5.3;"), 1) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Location start: 63"), 1) + self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Location end: 94"), 1) + errFD2.close() - outFD3 = open(self.testFilePath3+".out","r") - outFD3_lines = outFD3.readlines() - for i in range(len(outFD3_lines)): - outFD3_lines[i] = outFD3_lines[i].strip() + errFD3 = open(self.testFilePath3+".err","r") + errFD3_lines = errFD3.readlines() + for i in range(len(errFD3_lines)): + errFD3_lines[i] = errFD3_lines[i].strip() self.assertTrue(os.path.isfile(self.testFilePath3+".format"),"Patched .format file is not created?!") - self.assertEqual(outFD3_lines[0],"Number of Slither results: 1") - self.assertEqual(outFD3_lines[1],"Number of patches: 1") - self.assertEqual(outFD3_lines.count("Detector: solc-version"), 1) - self.assertEqual(outFD3_lines.count("Old string: pragma solidity >=0.4.0 <0.4.25;"), 1) - self.assertEqual(outFD3_lines.count("New string: pragma solidity 0.4.25;"), 1) - self.assertEqual(outFD3_lines.count("Location start: 63"), 1) - self.assertEqual(outFD3_lines.count("Location end: 95"), 1) - outFD3.close() + self.assertEqual(errFD3_lines[0],"INFO:Slither.Format:Number of Slither results: 1") + self.assertEqual(errFD3_lines[1],"INFO:Slither.Format:Number of patches: 1") + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Detector: solc-version"), 1) + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Old string: pragma solidity >=0.4.0 <0.4.25;"), 1) + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:New string: pragma solidity 0.4.25;"), 1) + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Location start: 63"), 1) + self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Location end: 95"), 1) + errFD3.close() - outFD4 = open(self.testFilePath4+".out","r") - outFD4_lines = outFD4.readlines() - for i in range(len(outFD4_lines)): - outFD4_lines[i] = outFD4_lines[i].strip() + errFD4 = open(self.testFilePath4+".err","r") + errFD4_lines = errFD4.readlines() + for i in range(len(errFD4_lines)): + errFD4_lines[i] = errFD4_lines[i].strip() self.assertTrue(os.path.isfile(self.testFilePath4+".format"),"Patched .format file is not created?!") - self.assertEqual(outFD4_lines[0],"Number of Slither results: 1") - self.assertEqual(outFD4_lines[1],"Number of patches: 1") - self.assertEqual(outFD4_lines.count("Detector: solc-version"), 1) - self.assertEqual(outFD4_lines.count("Old string: pragma solidity ^0.5.1;"), 1) - self.assertEqual(outFD4_lines.count("New string: pragma solidity 0.5.3;"), 1) - self.assertEqual(outFD4_lines.count("Location start: 63"), 1) - self.assertEqual(outFD4_lines.count("Location end: 86"), 1) - outFD4.close() + self.assertEqual(errFD4_lines[0],"INFO:Slither.Format:Number of Slither results: 1") + self.assertEqual(errFD4_lines[1],"INFO:Slither.Format:Number of patches: 1") + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Detector: solc-version"), 1) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Old string: pragma solidity ^0.5.1;"), 1) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:New string: pragma solidity 0.5.3;"), 1) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location start: 63"), 1) + self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location end: 86"), 1) + errFD4.close() if __name__ == '__main__': unittest.main() diff --git a/utils/slither_format/tests/test_unused_state_vars.py b/utils/slither_format/tests/test_unused_state_vars.py index d290fc38a..c5ec2011e 100644 --- a/utils/slither_format/tests/test_unused_state_vars.py +++ b/utils/slither_format/tests/test_unused_state_vars.py @@ -19,19 +19,19 @@ class TestUnusedStateVars(unittest.TestCase): p.wait() def test_unused_state_vars(self): - outFD = open(self.testFilePath+".out","r") - outFD_lines = outFD.readlines() - for i in range(len(outFD_lines)): - outFD_lines[i] = outFD_lines[i].strip() + errFD = open(self.testFilePath+".err","r") + errFD_lines = errFD.readlines() + for i in range(len(errFD_lines)): + errFD_lines[i] = errFD_lines[i].strip() self.assertTrue(os.path.isfile(self.testFilePath+".format"),"Patched .format file is not created?!") - self.assertEqual(outFD_lines[0].rstrip(),"Number of Slither results: 1") - self.assertEqual(outFD_lines[1].rstrip(),"Number of patches: 1") - self.assertEqual(outFD_lines.count("Detector: unused-state"), 1) - self.assertEqual(outFD_lines.count("Old string: address unused ;"), 1) - self.assertEqual(outFD_lines.count("New string:"), 1) - self.assertEqual(outFD_lines.count("Location start: 44"), 1) - self.assertEqual(outFD_lines.count("Location end: 63"), 1) - outFD.close() + self.assertEqual(errFD_lines[0].rstrip(),"INFO:Slither.Format:Number of Slither results: 1") + self.assertEqual(errFD_lines[1].rstrip(),"INFO:Slither.Format:Number of patches: 1") + self.assertEqual(errFD_lines.count("INFO:Slither.Format:Detector: unused-state"), 1) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:Old string: address unused ;"), 1) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:New string:"), 1) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:Location start: 44"), 1) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:Location end: 63"), 1) + errFD.close() if __name__ == '__main__': unittest.main() From 6c1dd58eec2e7d559eec72bb87f85a34b9a789c1 Mon Sep 17 00:00:00 2001 From: rajeevgopalakrishna Date: Tue, 21 May 2019 15:56:25 +0530 Subject: [PATCH 029/223] Fixes a regex bug (missing space) in formatting external-function. --- utils/slither_format/format_external_function.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/utils/slither_format/format_external_function.py b/utils/slither_format/format_external_function.py index 5fffb9879..9c9b82a47 100644 --- a/utils/slither_format/format_external_function.py +++ b/utils/slither_format/format_external_function.py @@ -27,7 +27,7 @@ class FormatExternalFunction: def create_patch(slither, patches, in_file, match_text, replace_text, modify_loc_start, modify_loc_end): in_file_str = slither.source_code[in_file] old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - m = re.search("public", old_str_of_interest) + m = re.search(" public", old_str_of_interest) if m is None: # No visibility specifier exists; public by default. patches[in_file].append({ @@ -40,7 +40,7 @@ class FormatExternalFunction: else: patches[in_file].append({ "detector" : "external-function", - "start" : modify_loc_start + m.span()[0], + "start" : modify_loc_start + m.span()[0] + 1, "end" : modify_loc_start + m.span()[1], "old_string" : match_text, "new_string" : replace_text From 4b09dc702b2375322c65513f5922d9fd2a1b6635 Mon Sep 17 00:00:00 2001 From: rajeevgopalakrishna Date: Wed, 22 May 2019 10:22:46 +0530 Subject: [PATCH 030/223] Adds missing import of sys. --- utils/slither_format/format_constable_states.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/utils/slither_format/format_constable_states.py b/utils/slither_format/format_constable_states.py index 0cf93b967..216de9fbb 100644 --- a/utils/slither_format/format_constable_states.py +++ b/utils/slither_format/format_constable_states.py @@ -1,4 +1,4 @@ -import re, logging +import re, logging, sys from slither.utils.colors import red, yellow, set_colorization_enabled logging.basicConfig(level=logging.INFO) From 85c3133634d68a492e976d10de8854c6b110ab43 Mon Sep 17 00:00:00 2001 From: rajeevgopalakrishna Date: Wed, 22 May 2019 15:02:24 +0530 Subject: [PATCH 031/223] Addresses source mapping utf-8 related issue fixed by #252. --- .../slither_format/format_constable_states.py | 6 +- .../format_constant_function.py | 4 +- .../format_external_function.py | 8 +- .../format_naming_convention.py | 146 +++++++++--------- utils/slither_format/format_pragma.py | 4 +- utils/slither_format/format_solc_version.py | 4 +- utils/slither_format/format_unused_state.py | 6 +- utils/slither_format/slither_format.py | 8 +- utils/slither_format/tests/run_all_tests.py | 31 ++-- .../tests/test_data/unicode.sol | 4 + utils/slither_format/tests/test_unicode.py | 37 +++++ 11 files changed, 151 insertions(+), 107 deletions(-) create mode 100644 utils/slither_format/tests/test_data/unicode.sol create mode 100644 utils/slither_format/tests/test_unicode.py diff --git a/utils/slither_format/format_constable_states.py b/utils/slither_format/format_constable_states.py index 216de9fbb..ee433a9ad 100644 --- a/utils/slither_format/format_constable_states.py +++ b/utils/slither_format/format_constable_states.py @@ -14,15 +14,15 @@ class FormatConstableStates: @staticmethod def create_patch(slither, patches, in_file, match_text, replace_text, modify_loc_start, modify_loc_end): - in_file_str = slither.source_code[in_file] + in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - (new_str_of_interest, num_repl) = re.subn(match_text, replace_text, old_str_of_interest, 1) + (new_str_of_interest, num_repl) = re.subn(match_text, replace_text, old_str_of_interest.decode('utf-8'), 1) if num_repl != 0: patches[in_file].append({ "detector" : "constable-states", "start" : modify_loc_start, "end" : modify_loc_end, - "old_string" : old_str_of_interest, + "old_string" : old_str_of_interest.decode('utf-8'), "new_string" : new_str_of_interest }) else: diff --git a/utils/slither_format/format_constant_function.py b/utils/slither_format/format_constant_function.py index a4435e9ae..333015507 100644 --- a/utils/slither_format/format_constant_function.py +++ b/utils/slither_format/format_constant_function.py @@ -23,9 +23,9 @@ class FormatConstantFunction: @staticmethod def create_patch(slither, patches, in_file, match_text, replace_text, modify_loc_start, modify_loc_end): - in_file_str = slither.source_code[in_file] + in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - m = re.search("(view|pure|constant)", old_str_of_interest) + m = re.search("(view|pure|constant)", old_str_of_interest.decode('utf-8')) if m: patches[in_file].append({ "detector" : "constant-function", diff --git a/utils/slither_format/format_external_function.py b/utils/slither_format/format_external_function.py index 9c9b82a47..8b769a67b 100644 --- a/utils/slither_format/format_external_function.py +++ b/utils/slither_format/format_external_function.py @@ -25,15 +25,15 @@ class FormatExternalFunction: @staticmethod def create_patch(slither, patches, in_file, match_text, replace_text, modify_loc_start, modify_loc_end): - in_file_str = slither.source_code[in_file] + in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - m = re.search(" public", old_str_of_interest) + m = re.search(" public", old_str_of_interest.decode('utf-8')) if m is None: # No visibility specifier exists; public by default. patches[in_file].append({ "detector" : "external-function", - "start" : modify_loc_start + len(old_str_of_interest.split(')')[0]) + 1, - "end" : modify_loc_start + len(old_str_of_interest.split(')')[0]) + 1, + "start" : modify_loc_start + len(old_str_of_interest.decode('utf-8').split(')')[0]) + 1, + "end" : modify_loc_start + len(old_str_of_interest.decode('utf-8').split(')')[0]) + 1, "old_string" : "", "new_string" : " " + replace_text }) diff --git a/utils/slither_format/format_naming_convention.py b/utils/slither_format/format_naming_convention.py index 1fffbb2c2..78330492a 100644 --- a/utils/slither_format/format_naming_convention.py +++ b/utils/slither_format/format_naming_convention.py @@ -56,17 +56,17 @@ class FormatNamingConvention: def create_patch_contract_definition(slither, patches, name, in_file, modify_loc_start, modify_loc_end): for contract in slither.contracts: if contract.name == name: - in_file_str = slither.source_code[in_file] + in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - m = re.match(r'(.*)'+"contract"+r'(.*)'+name, old_str_of_interest) + m = re.match(r'(.*)'+"contract"+r'(.*)'+name, old_str_of_interest.decode('utf-8')) old_str_of_interest = in_file_str[modify_loc_start:modify_loc_start+m.span()[1]] - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"contract"+r'(.*)'+name, r'\1'+"contract"+r'\2'+name.capitalize(), old_str_of_interest, 1) + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"contract"+r'(.*)'+name, r'\1'+"contract"+r'\2'+name.capitalize(), old_str_of_interest.decode('utf-8'), 1) if num_repl != 0: patch = { "detector" : "naming-convention (contract definition)", "start":modify_loc_start, "end":modify_loc_start+m.span()[1], - "old_string":old_str_of_interest, + "old_string":old_str_of_interest.decode('utf-8'), "new_string":new_str_of_interest } if not patch in patches[in_file]: @@ -79,19 +79,19 @@ class FormatNamingConvention: def create_patch_contract_uses(slither, patches, name, in_file): for contract in slither.contracts: if contract.name != name: - in_file_str = slither.source_code[in_file] + in_file_str = slither.source_code[in_file].encode('utf-8') # Check state variables of contract type # To-do: Deep-check aggregate types (struct and mapping) svs = contract.variables for sv in svs: if (str(sv.type) == name): old_str_of_interest = in_file_str[sv.source_mapping['start']:(sv.source_mapping['start']+sv.source_mapping['length'])] - (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(),old_str_of_interest, 1) + (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(),old_str_of_interest.decode('utf-8'), 1) patch = { "detector" : "naming-convention (contract state variable)", "start" : sv.source_mapping['start'], "end" : sv.source_mapping['start'] + sv.source_mapping['length'], - "old_string" : old_str_of_interest, + "old_string" : old_str_of_interest.decode('utf-8'), "new_string" : new_str_of_interest } if not patch in patches[in_file]: @@ -103,12 +103,12 @@ class FormatNamingConvention: for v in fm.variables: if (str(v.type) == name): old_str_of_interest = in_file_str[v.source_mapping['start']:(v.source_mapping['start']+v.source_mapping['length'])] - (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(),old_str_of_interest, 1) + (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(),old_str_of_interest.decode('utf-8'), 1) patch = { "detector" : "naming-convention (contract function variable)", "start" : v.source_mapping['start'], "end" : v.source_mapping['start'] + v.source_mapping['length'], - "old_string" : old_str_of_interest, + "old_string" : old_str_of_interest.decode('utf-8'), "new_string" : new_str_of_interest } if not patch in patches[in_file]: @@ -119,8 +119,8 @@ class FormatNamingConvention: for ir in node.irs: if isinstance(ir, NewContract) and ir.contract_name == name: old_str_of_interest = in_file_str[node.source_mapping['start']:node.source_mapping['start'] + node.source_mapping['length']] - m = re.search("new"+r'(.*)'+name, old_str_of_interest) - old_str_of_interest = old_str_of_interest[m.span()[0]:] + m = re.search("new"+r'(.*)'+name, old_str_of_interest.decode('utf-8')) + old_str_of_interest = old_str_of_interest.decode('utf-8')[m.span()[0]:] (new_str_of_interest, num_repl) = re.subn("new"+r'(.*)'+name, "new"+r'\1'+name[0].upper()+name[1:], old_str_of_interest, 1) if num_repl != 0: patch = { @@ -146,17 +146,17 @@ class FormatNamingConvention: if contract.name == contract_name: for modifier in contract.modifiers: if modifier.name == name: - in_file_str = slither.source_code[in_file] + in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - m = re.match(r'(.*)'+"modifier"+r'(.*)'+name, old_str_of_interest) + m = re.match(r'(.*)'+"modifier"+r'(.*)'+name, old_str_of_interest.decode('utf-8')) old_str_of_interest = in_file_str[modify_loc_start:modify_loc_start+m.span()[1]] - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"modifier"+r'(.*)'+name, r'\1'+"modifier"+r'\2'+name[0].lower()+name[1:], old_str_of_interest, 1) + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"modifier"+r'(.*)'+name, r'\1'+"modifier"+r'\2'+name[0].lower()+name[1:], old_str_of_interest.decode('utf-8'), 1) if num_repl != 0: patch = { "detector" : "naming-convention (modifier definition)", "start" : modify_loc_start, "end" : modify_loc_start+m.span()[1], - "old_string" : old_str_of_interest, + "old_string" : old_str_of_interest.decode('utf-8'), "new_string" : new_str_of_interest } if not patch in patches[in_file]: @@ -175,15 +175,15 @@ class FormatNamingConvention: for function in contract.functions: for m in function.modifiers: if (m.name == name): - in_file_str = slither.source_code[in_file] + in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[int(function.parameters_src.source_mapping['start']):int(function.returns_src.source_mapping['start'])] - (new_str_of_interest, num_repl) = re.subn(name, name[0].lower()+name[1:],old_str_of_interest,1) + (new_str_of_interest, num_repl) = re.subn(name, name[0].lower()+name[1:],old_str_of_interest.decode('utf-8'),1) if num_repl != 0: patch = { "detector" : "naming-convention (modifier uses)", "start" : int(function.parameters_src.source_mapping['start']), "end" : int(function.returns_src.source_mapping['start']), - "old_string" : old_str_of_interest, + "old_string" : old_str_of_interest.decode('utf-8'), "new_string" : new_str_of_interest } if not patch in patches[in_file]: @@ -198,17 +198,17 @@ class FormatNamingConvention: if contract.name == contract_name: for function in contract.functions: if function.name == name: - in_file_str = slither.source_code[in_file] + in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - m = re.match(r'(.*)'+"function"+r'(.*)'+name, old_str_of_interest) + m = re.match(r'(.*)'+"function"+r'(.*)'+name, old_str_of_interest.decode('utf-8')) old_str_of_interest = in_file_str[modify_loc_start:modify_loc_start+m.span()[1]] - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"function"+r'(.*)'+name, r'\1'+"function"+r'\2'+name[0].lower()+name[1:], old_str_of_interest, 1) + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"function"+r'(.*)'+name, r'\1'+"function"+r'\2'+name[0].lower()+name[1:], old_str_of_interest.decode('utf-8'), 1) if num_repl != 0: patch = { "detector" : "naming-convention (function definition)", "start" : modify_loc_start, "end" : modify_loc_start+m.span()[1], - "old_string" : old_str_of_interest, + "old_string" : old_str_of_interest.decode('utf-8'), "new_string" : new_str_of_interest } if not patch in patches[in_file]: @@ -227,30 +227,30 @@ class FormatNamingConvention: for external_call in node.external_calls_as_expressions: called_function = str(external_call.called).split('.')[-1] if called_function == high_level_call[1].name: - in_file_str = slither.source_code[in_file] + in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[int(external_call.source_mapping['start']):int(external_call.source_mapping['start'])+int(external_call.source_mapping['length'])] - called_function_name = old_str_of_interest.split('.')[-1] + called_function_name = old_str_of_interest.decode('utf-8').split('.')[-1] fixed_function_name = called_function_name[0].lower() + called_function_name[1:] - new_string = '.'.join(old_str_of_interest.split('.')[:-1]) + '.' + fixed_function_name + new_string = '.'.join(old_str_of_interest.decode('utf-8').split('.')[:-1]) + '.' + fixed_function_name patch = { "detector" : "naming-convention (function calls)", "start" : external_call.source_mapping['start'], "end" : int(external_call.source_mapping['start']) + int(external_call.source_mapping['length']), - "old_string" : old_str_of_interest, + "old_string" : old_str_of_interest.decode('utf-8'), "new_string" : new_string } if not patch in patches[in_file]: patches[in_file].append(patch) for internal_call in node.internal_calls_as_expressions: if (str(internal_call.called) == name): - in_file_str = slither.source_code[in_file] + in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[int(internal_call.source_mapping['start']):int(internal_call.source_mapping['start'])+int(internal_call.source_mapping['length'])] patch = { "detector" : "naming-convention (function calls)", "start" : internal_call.source_mapping['start'], "end" : int(internal_call.source_mapping['start']) + int(internal_call.source_mapping['length']), - "old_string" : old_str_of_interest, - "new_string" : old_str_of_interest[0].lower()+old_str_of_interest[1:] + "old_string" : old_str_of_interest.decode('utf-8'), + "new_string" : old_str_of_interest.decode('utf-8')[0].lower()+old_str_of_interest.decode('utf-8')[1:] } if not patch in patches[in_file]: patches[in_file].append(patch) @@ -262,15 +262,15 @@ class FormatNamingConvention: for event in contract.events: if event.name == name: event_name = name.split('(')[0] - in_file_str = slither.source_code[in_file] + in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"event"+r'(.*)'+event_name, r'\1'+"event"+r'\2'+event_name[0].capitalize()+event_name[1:], old_str_of_interest, 1) + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"event"+r'(.*)'+event_name, r'\1'+"event"+r'\2'+event_name[0].capitalize()+event_name[1:], old_str_of_interest.decode('utf-8'), 1) if num_repl != 0: patch = { "detector" : "naming-convention (event definition)", "start" : modify_loc_start, "end" : modify_loc_end, - "old_string" : old_str_of_interest, + "old_string" : old_str_of_interest.decode('utf-8'), "new_string" : new_str_of_interest } if not patch in patches[in_file]: @@ -291,14 +291,14 @@ class FormatNamingConvention: for node in function.nodes: for call in node.internal_calls_as_expressions: if (str(call.called) == event_name): - in_file_str = slither.source_code[in_file] + in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[int(call.source_mapping['start']):int(call.source_mapping['start'])+int(call.source_mapping['length'])] patch = { "detector" : "naming-convention (event calls)", "start" : call.source_mapping['start'], "end" : int(call.source_mapping['start']) + int(call.source_mapping['length']), - "old_string" : old_str_of_interest, - "new_string" : old_str_of_interest[0].capitalize()+old_str_of_interest[1:] + "old_string" : old_str_of_interest.decode('utf-8'), + "new_string" : old_str_of_interest.decode('utf-8')[0].capitalize()+old_str_of_interest.decode('utf-8')[1:] } if not patch in patches[in_file]: patches[in_file].append(patch) @@ -309,18 +309,18 @@ class FormatNamingConvention: if contract.name == contract_name: for function in contract.functions: if function.name == function_name: - in_file_str = slither.source_code[in_file] + in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] if(name[0] == '_'): - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+name[0]+name[1].upper()+name[2:]+r'\2', old_str_of_interest, 1) + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+name[0]+name[1].upper()+name[2:]+r'\2', old_str_of_interest.decode('utf-8'), 1) else: - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+'_'+name[0].upper()+name[1:]+r'\2', old_str_of_interest, 1) + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+'_'+name[0].upper()+name[1:]+r'\2', old_str_of_interest.decode('utf-8'), 1) if num_repl != 0: patch = { "detector" : "naming-convention (parameter declaration)", "start" : modify_loc_start, "end" : modify_loc_end, - "old_string" : old_str_of_interest, + "old_string" : old_str_of_interest.decode('utf-8'), "new_string" : new_str_of_interest } if not patch in patches[in_file]: @@ -335,7 +335,7 @@ class FormatNamingConvention: if (contract.name == contract_name): for function in contract.functions: if (function.name == function_name): - in_file_str = slither.source_code[in_file] + in_file_str = slither.source_code[in_file].encode('utf-8') for node in function.nodes: vars = node._expression_vars_written + node._expression_vars_read for v in vars: @@ -344,15 +344,15 @@ class FormatNamingConvention: modify_loc_end = int(v.source_mapping['start']) + int(v.source_mapping['length']) old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] if(name[0] == '_'): - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+name[0]+name[1].upper()+name[2:]+r'\2', old_str_of_interest, 1) + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+name[0]+name[1].upper()+name[2:]+r'\2', old_str_of_interest.decode('utf-8'), 1) else: - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+'_'+name[0].upper()+name[1:]+r'\2', old_str_of_interest, 1) + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+'_'+name[0].upper()+name[1:]+r'\2', old_str_of_interest.decode('utf-8'), 1) if num_repl != 0: patch = { "detector" : "naming-convention (parameter uses)", "start" : modify_loc_start, "end" : modify_loc_end, - "old_string" : old_str_of_interest, + "old_string" : old_str_of_interest.decode('utf-8'), "new_string" : new_str_of_interest } if not patch in patches[in_file]: @@ -366,7 +366,7 @@ class FormatNamingConvention: for arg in modifier.arguments: if str(arg) == name: old_str_of_interest = in_file_str[modifier.source_mapping['start']:modifier.source_mapping['start']+modifier.source_mapping['length']] - old_str_of_interest_beyond_modifier_name = old_str_of_interest.split('(')[1] + old_str_of_interest_beyond_modifier_name = old_str_of_interest.decode('utf-8').split('(')[1] if(name[0] == '_'): (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+name[0]+name[1].upper()+name[2:]+r'\2', old_str_of_interest_beyond_modifier_name, 1) else: @@ -374,7 +374,7 @@ class FormatNamingConvention: if num_repl != 0: patch = { "detector" : "naming-convention (parameter uses)", - "start" : modifier.source_mapping['start'] + len(old_str_of_interest.split('(')[0]) + 1, + "start" : modifier.source_mapping['start'] + len(old_str_of_interest.decode('utf-8').split('(')[0]) + 1, "end" : modifier.source_mapping['start'] + modifier.source_mapping['length'], "old_string" : old_str_of_interest_beyond_modifier_name, "new_string" : new_str_of_interest @@ -391,19 +391,19 @@ class FormatNamingConvention: if (contract.name == contract_name): for var in contract.state_variables: if (var.name == name): - in_file_str = slither.source_code[in_file] + in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - m = re.search(name, old_str_of_interest) + m = re.search(name, old_str_of_interest.decode('utf-8')) if (_target == "variable_constant"): - new_string = old_str_of_interest[m.span()[0]:m.span()[1]].upper() + new_string = old_str_of_interest.decode('utf-8')[m.span()[0]:m.span()[1]].upper() else: - new_string = old_str_of_interest[m.span()[0]:m.span()[1]] + new_string = old_str_of_interest.decode('utf-8')[m.span()[0]:m.span()[1]] new_string = new_string[0].lower()+new_string[1:] patch = { "detector" : "naming-convention (state variable declaration)", "start" : modify_loc_start+m.span()[0], "end" : modify_loc_start+m.span()[1], - "old_string" : old_str_of_interest[m.span()[0]:m.span()[1]], + "old_string" : old_str_of_interest.decode('utf-8')[m.span()[0]:m.span()[1]], "new_string" : new_string } if not patch in patches[in_file]: @@ -425,18 +425,18 @@ class FormatNamingConvention: if isinstance(v, Identifier) and str(v) == name and [str(sv) for sv in (node._state_vars_read+node._state_vars_written) if str(sv) == name]: modify_loc_start = int(v.source_mapping['start']) modify_loc_end = int(v.source_mapping['start']) + int(v.source_mapping['length']) - in_file_str = slither.source_code[in_file] + in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] if (_target == "variable_constant"): - new_str_of_interest = old_str_of_interest.upper() + new_str_of_interest = old_str_of_interest.decode('utf-8').upper() else: - new_str_of_interest = old_str_of_interest + new_str_of_interest = old_str_of_interest.decode('utf-8') new_str_of_interest = new_str_of_interest[0].lower()+new_str_of_interest[1:] patch = { "detector" : "naming-convention (state variable uses)", "start" : modify_loc_start, "end" : modify_loc_end, - "old_string" : old_str_of_interest, + "old_string" : old_str_of_interest.decode('utf-8'), "new_string" : new_str_of_interest } if not patch in patches[in_file]: @@ -448,15 +448,15 @@ class FormatNamingConvention: if (contract.name == contract_name): for enum in contract.enums: if (enum.name == name): - in_file_str = slither.source_code[in_file] + in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"enum"+r'(.*)'+name, r'\1'+"enum"+r'\2'+name[0].capitalize()+name[1:], old_str_of_interest, 1) + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"enum"+r'(.*)'+name, r'\1'+"enum"+r'\2'+name[0].capitalize()+name[1:], old_str_of_interest.decode('utf-8'), 1) if num_repl != 0: patch = { "detector" : "naming-convention (enum definition)", "start" : modify_loc_start, "end" : modify_loc_end, - "old_string" : old_str_of_interest, + "old_string" : old_str_of_interest.decode('utf-8'), "new_string" : new_str_of_interest } if not patch in patches[in_file]: @@ -472,19 +472,19 @@ class FormatNamingConvention: target_contract = contract for contract in slither.contracts: if (contract == target_contract or (contract in target_contract.derived_contracts)): - in_file_str = slither.source_code[in_file] + in_file_str = slither.source_code[in_file].encode('utf-8') # Check state variable declarations of enum type # To-do: Deep-check aggregate types (struct and mapping) svs = contract.variables for sv in svs: if (str(sv.type) == contract_name + "." + name): old_str_of_interest = in_file_str[sv.source_mapping['start']:(sv.source_mapping['start']+sv.source_mapping['length'])] - (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(),old_str_of_interest, 1) + (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(),old_str_of_interest.decode('utf-8'), 1) patch = { "detector" : "naming-convention (enum use)", "start" : sv.source_mapping['start'], "end" : sv.source_mapping['start'] + sv.source_mapping['length'], - "old_string" : old_str_of_interest, + "old_string" : old_str_of_interest.decode('utf-8'), "new_string" : new_str_of_interest } if not patch in patches[in_file]: @@ -497,12 +497,12 @@ class FormatNamingConvention: for v in fm.variables: if (str(v.type) == contract_name + "." + name): old_str_of_interest = in_file_str[v.source_mapping['start']:(v.source_mapping['start']+v.source_mapping['length'])] - (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(),old_str_of_interest, 1) + (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(),old_str_of_interest.decode('utf-8'), 1) patch = { "detector" : "naming-convention (enum use)", "start" : v.source_mapping['start'], "end" : v.source_mapping['start'] + v.source_mapping['length'], - "old_string" : old_str_of_interest, + "old_string" : old_str_of_interest.decode('utf-8'), "new_string" : new_str_of_interest } if not patch in patches[in_file]: @@ -513,16 +513,16 @@ class FormatNamingConvention: for ir in node.irs: if isinstance(ir, Member): if str(ir.variable_left) == name: - old_str_of_interest = in_file_str[node.source_mapping['start']:(node.source_mapping['start']+node.source_mapping['length'])].split('=')[1] + old_str_of_interest = in_file_str[node.source_mapping['start']:(node.source_mapping['start']+node.source_mapping['length'])].decode('utf-8').split('=')[1] m = re.search(r'(.*)'+name, old_str_of_interest) old_str_of_interest = old_str_of_interest[m.span()[0]:] (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name, r'\1'+name[0].upper()+name[1:], old_str_of_interest, 1) if num_repl != 0: patch = { "detector" : "naming-convention (enum use)", - "start" : node.source_mapping['start'] + len(in_file_str[node.source_mapping['start']:(node.source_mapping['start']+node.source_mapping['length'])].split('=')[0]) + 1 + m.span()[0], + "start" : node.source_mapping['start'] + len(in_file_str[node.source_mapping['start']:(node.source_mapping['start']+node.source_mapping['length'])].decode('utf-8').split('=')[0]) + 1 + m.span()[0], "end" : node.source_mapping['start'] + len(in_file_str[node.source_mapping['star\ -t']:(node.source_mapping['start']+node.source_mapping['length'])].split('=')[0]) + 1 + m.span()[0] + len(old_str_of_interest), +t']:(node.source_mapping['start']+node.source_mapping['length'])].decode('utf-8').split('=')[0]) + 1 + m.span()[0] + len(old_str_of_interest), "old_string" : old_str_of_interest, "new_string" : new_str_of_interest } @@ -539,15 +539,15 @@ t']:(node.source_mapping['start']+node.source_mapping['length'])].split('=')[0]) if (contract.name == contract_name): for struct in contract.structures: if (struct.name == name): - in_file_str = slither.source_code[in_file] + in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"struct"+r'(.*)'+name, r'\1'+"struct"+r'\2'+name[0].capitalize()+name[1:], old_str_of_interest, 1) + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"struct"+r'(.*)'+name, r'\1'+"struct"+r'\2'+name[0].capitalize()+name[1:], old_str_of_interest.decode('utf-8'), 1) if num_repl != 0: patch = { "detector" : "naming-convention (struct definition)", "start" : modify_loc_start, "end" : modify_loc_end, - "old_string" : old_str_of_interest, + "old_string" : old_str_of_interest.decode('utf-8'), "new_string" : new_str_of_interest } if not patch in patches[in_file]: @@ -563,19 +563,19 @@ t']:(node.source_mapping['start']+node.source_mapping['length'])].split('=')[0]) target_contract = contract for contract in slither.contracts: if (contract == target_contract or (contract in target_contract.derived_contracts)): - in_file_str = slither.source_code[in_file] + in_file_str = slither.source_code[in_file].encode('utf-8') # Check state variables of struct type # To-do: Deep-check aggregate types (struct and mapping) svs = contract.variables for sv in svs: if (str(sv.type) == contract_name + "." + name): old_str_of_interest = in_file_str[sv.source_mapping['start']:(sv.source_mapping['start']+sv.source_mapping['length'])] - (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(),old_str_of_interest, 1) + (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(),old_str_of_interest.decode('utf-8'), 1) patch = { "detector" : "naming-convention (struct use)", "start" : sv.source_mapping['start'], "end" : sv.source_mapping['start'] + sv.source_mapping['length'], - "old_string" : old_str_of_interest, + "old_string" : old_str_of_interest.decode('utf-8'), "new_string" : new_str_of_interest } if not patch in patches[in_file]: @@ -587,12 +587,12 @@ t']:(node.source_mapping['start']+node.source_mapping['length'])].split('=')[0]) for v in fm.variables: if (str(v.type) == contract_name + "." + name): old_str_of_interest = in_file_str[v.source_mapping['start']:(v.source_mapping['start']+v.source_mapping['length'])] - (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(),old_str_of_interest, 1) + (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(),old_str_of_interest.decode('utf-8'), 1) patch = { "detector" : "naming-convention (struct use)", "start" : v.source_mapping['start'], "end" : v.source_mapping['start'] + v.source_mapping['length'], - "old_string" : old_str_of_interest, + "old_string" : old_str_of_interest.decode('utf-8'), "new_string" : new_str_of_interest } if not patch in patches[in_file]: diff --git a/utils/slither_format/format_pragma.py b/utils/slither_format/format_pragma.py index 29cc72285..013e04ed3 100644 --- a/utils/slither_format/format_pragma.py +++ b/utils/slither_format/format_pragma.py @@ -63,12 +63,12 @@ class FormatPragma: @staticmethod def create_patch(slither, patches, in_file, pragma, modify_loc_start, modify_loc_end): - in_file_str = slither.source_code[in_file] + in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] patches[in_file].append({ "detector" : "pragma", "start" : modify_loc_start, "end" : modify_loc_end, - "old_string" : old_str_of_interest, + "old_string" : old_str_of_interest.decode('utf-8'), "new_string" : pragma }) diff --git a/utils/slither_format/format_solc_version.py b/utils/slither_format/format_solc_version.py index ae35d33b1..e27ff60a5 100644 --- a/utils/slither_format/format_solc_version.py +++ b/utils/slither_format/format_solc_version.py @@ -49,12 +49,12 @@ class FormatSolcVersion: @staticmethod def create_patch(slither, patches, in_file, solc_version, modify_loc_start, modify_loc_end): - in_file_str = slither.source_code[in_file] + in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] patches[in_file].append({ "detector" : "solc-version", "start" : modify_loc_start, "end" : modify_loc_end, - "old_string" : old_str_of_interest, + "old_string" : old_str_of_interest.decode('utf-8'), "new_string" : solc_version }) diff --git a/utils/slither_format/format_unused_state.py b/utils/slither_format/format_unused_state.py index ec2ea63da..4a3e8c970 100644 --- a/utils/slither_format/format_unused_state.py +++ b/utils/slither_format/format_unused_state.py @@ -8,13 +8,13 @@ class FormatUnusedState: @staticmethod def create_patch(slither, patches, in_file, modify_loc_start): - in_file_str = slither.source_code[in_file] + in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:] patches[in_file].append({ "detector" : "unused-state", "start" : modify_loc_start, - "end" : modify_loc_start + len(old_str_of_interest.partition(';')[0]) + 1, - "old_string" : old_str_of_interest.partition(';')[0] + old_str_of_interest.partition(';')[1], + "end" : modify_loc_start + len(old_str_of_interest.decode('utf-8').partition(';')[0]) + 1, + "old_string" : old_str_of_interest.decode('utf-8').partition(';')[0] + old_str_of_interest.decode('utf-8').partition(';')[1], "new_string" : "" }) diff --git a/utils/slither_format/slither_format.py b/utils/slither_format/slither_format.py index eb7e3cfe1..a97bfcd34 100644 --- a/utils/slither_format/slither_format.py +++ b/utils/slither_format/slither_format.py @@ -90,16 +90,16 @@ def prune_overlapping_patches(args, patches): def apply_patches(slither, patches): for file in patches: _in_file = file - in_file_str = slither.source_code[_in_file] + in_file_str = slither.source_code[_in_file].encode('utf-8') out_file_str = "" for i in range(len(patches[file])): if i != 0: - out_file_str += in_file_str[int(patches[file][i-1]['end']):int(patches[file][i]['start'])] + out_file_str += in_file_str[int(patches[file][i-1]['end']):int(patches[file][i]['start'])].decode('utf-8') else: - out_file_str += in_file_str[:int(patches[file][i]['start'])] + out_file_str += in_file_str[:int(patches[file][i]['start'])].decode('utf-8') out_file_str += patches[file][i]['new_string'] if (i == (len(patches[file]) - 1)): - out_file_str += in_file_str[int(patches[file][i]['end']):] + out_file_str += in_file_str[int(patches[file][i]['end']):].decode('utf-8') out_file = open(_in_file+".format",'w') out_file.write(out_file_str) out_file.close() diff --git a/utils/slither_format/tests/run_all_tests.py b/utils/slither_format/tests/run_all_tests.py index 87ac64d20..d158a33bc 100644 --- a/utils/slither_format/tests/run_all_tests.py +++ b/utils/slither_format/tests/run_all_tests.py @@ -1,19 +1,22 @@ import subprocess -p1 = subprocess.Popen(['python3', './slither_format/tests/test_constable_states.py']) -p1.wait() -p2 = subprocess.Popen(['python3', './slither_format/tests/test_constant_function.py']) -p2.wait() -p3 = subprocess.Popen(['python3', './slither_format/tests/test_external_function.py']) -p3.wait() -p4 = subprocess.Popen(['python3', './slither_format/tests/test_unused_state_vars.py']) -p4.wait() -p5 = subprocess.Popen(['python3', './slither_format/tests/test_naming_convention.py']) -p5.wait() -p6 = subprocess.Popen(['python3', './slither_format/tests/test_pragma.py']) -p6.wait() -p7 = subprocess.Popen(['python3', './slither_format/tests/test_solc_version.py']) -p7.wait() +p9 = subprocess.Popen(['python3', './slither_format/tests/test_unicode.py']) +p9.wait() p8 = subprocess.Popen(['python3', './slither_format/tests/test_detector_combinations.py']) p8.wait() +p7 = subprocess.Popen(['python3', './slither_format/tests/test_solc_version.py']) +p7.wait() +p6 = subprocess.Popen(['python3', './slither_format/tests/test_pragma.py']) +p6.wait() +p5 = subprocess.Popen(['python3', './slither_format/tests/test_naming_convention.py']) +p5.wait() +p4 = subprocess.Popen(['python3', './slither_format/tests/test_unused_state_vars.py']) +p4.wait() +p3 = subprocess.Popen(['python3', './slither_format/tests/test_external_function.py']) +p3.wait() +p2 = subprocess.Popen(['python3', './slither_format/tests/test_constant_function.py']) +p2.wait() +p1 = subprocess.Popen(['python3', './slither_format/tests/test_constable_states.py']) +p1.wait() + diff --git a/utils/slither_format/tests/test_data/unicode.sol b/utils/slither_format/tests/test_data/unicode.sol new file mode 100644 index 000000000..19c83c44a --- /dev/null +++ b/utils/slither_format/tests/test_data/unicode.sol @@ -0,0 +1,4 @@ +contract C { + //领 + uint sv; +} diff --git a/utils/slither_format/tests/test_unicode.py b/utils/slither_format/tests/test_unicode.py new file mode 100644 index 000000000..dcfeb11ca --- /dev/null +++ b/utils/slither_format/tests/test_unicode.py @@ -0,0 +1,37 @@ +import unittest +import subprocess, os, sys + +class TestUnicode(unittest.TestCase): + testDataFile = "unicode.sol" + testDataDir = "./slither_format/tests/test_data/" + testFilePath = testDataDir+testDataFile + + def setUp(self): + outFD = open(self.testFilePath+".out","w") + errFD = open(self.testFilePath+".err","w") + p = subprocess.Popen(['python3', '-m', 'slither_format','--verbose-test',self.testFilePath], stdout=outFD,stderr=errFD) + p.wait() + outFD.close() + errFD.close() + + def tearDown(self): + p = subprocess.Popen(['rm','-f',self.testFilePath+'.out',self.testFilePath+'.err',self.testFilePath+'.format']) + p.wait() + + def test_constable_states(self): + errFD = open(self.testFilePath+".err","r") + errFD_lines = errFD.readlines() + for i in range(len(errFD_lines)): + errFD_lines[i] = errFD_lines[i].strip() + self.assertTrue(os.path.isfile(self.testFilePath+".format"),"Patched .format file is not created?!") + self.assertEqual(errFD_lines[0].rstrip(),"INFO:Slither.Format:Number of Slither results: 1") + self.assertEqual(errFD_lines[1].rstrip(),"INFO:Slither.Format:Number of patches: 1") + self.assertEqual(errFD_lines.count("INFO:Slither.Format:Detector: constable-states"), 1) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:Old string: uint sv"), 1) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:New string: uint constant sv"), 1) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:Location start: 23"), 1) + self.assertEqual(errFD_lines.count("INFO:Slither.Format:Location end: 30"), 1) + errFD.close() + +if __name__ == '__main__': + unittest.main() From 10e31b08935b594a431908a5f89975599d3b5d53 Mon Sep 17 00:00:00 2001 From: rajeevgopalakrishna Date: Wed, 22 May 2019 18:09:23 +0530 Subject: [PATCH 032/223] Fixes a false alarm about converting the empty string parameter name to mixedCase (#260). --- slither/detectors/naming_convention/naming_convention.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/slither/detectors/naming_convention/naming_convention.py b/slither/detectors/naming_convention/naming_convention.py index 61d917b26..9c69e41ba 100644 --- a/slither/detectors/naming_convention/naming_convention.py +++ b/slither/detectors/naming_convention/naming_convention.py @@ -104,6 +104,9 @@ Solidity defines a [naming convention](https://solidity.readthedocs.io/en/v0.4.2 results.append(json) for argument in func.parameters: + # Ignore parameter names that are not specified i.e. empty strings + if argument.name == "": + continue if argument in func.variables_read_or_written: correct_naming = self.is_mixed_case(argument.name) else: From f4b679a0f73887017ee43e53339c9be7b0174c93 Mon Sep 17 00:00:00 2001 From: rajeevgopalakrishna Date: Thu, 23 May 2019 07:13:44 +0530 Subject: [PATCH 033/223] Adds slither-format to setup.py. --- setup.py | 1 + 1 file changed, 1 insertion(+) diff --git a/setup.py b/setup.py index d6642a502..c4c2e581a 100644 --- a/setup.py +++ b/setup.py @@ -17,6 +17,7 @@ setup( 'slither-check-upgradeability = utils.upgradeability.__main__:main', 'slither-find-paths = utils.possible_paths.__main__:main', 'slither-simil = utils.similarity.__main__:main' + 'slither-format = utils.slither_format.__main__:main' ] } ) From 9e482a4f928f538c04df4793dc27546751828035 Mon Sep 17 00:00:00 2001 From: rajeevgopalakrishna Date: Thu, 23 May 2019 15:11:13 +0530 Subject: [PATCH 034/223] Adds patch file creation. Keeps track of relative and absolute file names. Fixes bug in patch overlap and naming-convention of function definition/calls and contract function variable. --- utils/slither_format/.gitignore | 2 + .../slither_format/format_constable_states.py | 7 +- .../format_constant_function.py | 7 +- .../format_external_function.py | 10 +- .../format_naming_convention.py | 205 ++++++++++-------- utils/slither_format/format_pragma.py | 9 +- utils/slither_format/format_solc_version.py | 7 +- utils/slither_format/format_unused_state.py | 7 +- utils/slither_format/slither_format.py | 20 +- .../tests/test_detector_combinations.py | 7 +- .../tests/test_naming_convention.py | 12 +- .../slither_format/tests/test_solc_version.py | 4 +- 12 files changed, 170 insertions(+), 127 deletions(-) diff --git a/utils/slither_format/.gitignore b/utils/slither_format/.gitignore index d356da7f4..cbef61e67 100644 --- a/utils/slither_format/.gitignore +++ b/utils/slither_format/.gitignore @@ -1,5 +1,7 @@ # .format files are the output files produced by slither-format +# .patch files are the output files produced by slither-format *.format +*.patch # Temporary files (Emacs backup files ending in tilde and others) *~ diff --git a/utils/slither_format/format_constable_states.py b/utils/slither_format/format_constable_states.py index ee433a9ad..6f221fce7 100644 --- a/utils/slither_format/format_constable_states.py +++ b/utils/slither_format/format_constable_states.py @@ -10,15 +10,16 @@ class FormatConstableStates: @staticmethod def format(slither, patches, elements): for element in elements: - FormatConstableStates.create_patch(slither, patches, element['source_mapping']['filename_absolute'], element['name'], "constant " + element['name'], element['source_mapping']['start'], element['source_mapping']['start'] + element['source_mapping']['length']) + FormatConstableStates.create_patch(slither, patches, element['source_mapping']['filename_absolute'], element['source_mapping']['filename_relative'], element['name'], "constant " + element['name'], element['source_mapping']['start'], element['source_mapping']['start'] + element['source_mapping']['length']) @staticmethod - def create_patch(slither, patches, in_file, match_text, replace_text, modify_loc_start, modify_loc_end): + def create_patch(slither, patches, in_file, in_file_relative, match_text, replace_text, modify_loc_start, modify_loc_end): in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] (new_str_of_interest, num_repl) = re.subn(match_text, replace_text, old_str_of_interest.decode('utf-8'), 1) if num_repl != 0: - patches[in_file].append({ + patches[in_file_relative].append({ + "file" : in_file, "detector" : "constable-states", "start" : modify_loc_start, "end" : modify_loc_end, diff --git a/utils/slither_format/format_constant_function.py b/utils/slither_format/format_constant_function.py index 333015507..b82fc89a2 100644 --- a/utils/slither_format/format_constant_function.py +++ b/utils/slither_format/format_constant_function.py @@ -18,16 +18,17 @@ class FormatConstantFunction: if not Found: for function in contract.functions: if contract.name == element['type_specific_fields']['parent']['name'] and function.name == element['name']: - FormatConstantFunction.create_patch(slither, patches, element['source_mapping']['filename_absolute'], ["view","pure","constant"], "", int(function.parameters_src.source_mapping['start']), int(function.returns_src.source_mapping['start'])) + FormatConstantFunction.create_patch(slither, patches, element['source_mapping']['filename_absolute'], element['source_mapping']['filename_relative'], ["view","pure","constant"], "", int(function.parameters_src.source_mapping['start']), int(function.returns_src.source_mapping['start'])) Found = True @staticmethod - def create_patch(slither, patches, in_file, match_text, replace_text, modify_loc_start, modify_loc_end): + def create_patch(slither, patches, in_file, in_file_relative, match_text, replace_text, modify_loc_start, modify_loc_end): in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] m = re.search("(view|pure|constant)", old_str_of_interest.decode('utf-8')) if m: - patches[in_file].append({ + patches[in_file_relative].append({ + "file" : in_file, "detector" : "constant-function", "start" : modify_loc_start + m.span()[0], "end" : modify_loc_start + m.span()[1], diff --git a/utils/slither_format/format_external_function.py b/utils/slither_format/format_external_function.py index 8b769a67b..2ba08cc06 100644 --- a/utils/slither_format/format_external_function.py +++ b/utils/slither_format/format_external_function.py @@ -19,18 +19,19 @@ class FormatExternalFunction: # to external because external function parameters are allocated in calldata region which is # non-modifiable. See https://solidity.readthedocs.io/en/develop/types.html#data-location if not FormatExternalFunction.function_parameters_written(function): - FormatExternalFunction.create_patch(slither, patches, element['source_mapping']['filename_absolute'], "public", "external", int(function.parameters_src.source_mapping['start']), int(function.returns_src.source_mapping['start'])) + FormatExternalFunction.create_patch(slither, patches, element['source_mapping']['filename_absolute'], element['source_mapping']['filename_relative'], "public", "external", int(function.parameters_src.source_mapping['start']), int(function.returns_src.source_mapping['start'])) Found = True break @staticmethod - def create_patch(slither, patches, in_file, match_text, replace_text, modify_loc_start, modify_loc_end): + def create_patch(slither, patches, in_file, in_file_relative, match_text, replace_text, modify_loc_start, modify_loc_end): in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] m = re.search(" public", old_str_of_interest.decode('utf-8')) if m is None: # No visibility specifier exists; public by default. - patches[in_file].append({ + patches[in_file_relative].append({ + "file" : in_file, "detector" : "external-function", "start" : modify_loc_start + len(old_str_of_interest.decode('utf-8').split(')')[0]) + 1, "end" : modify_loc_start + len(old_str_of_interest.decode('utf-8').split(')')[0]) + 1, @@ -38,7 +39,8 @@ class FormatExternalFunction: "new_string" : " " + replace_text }) else: - patches[in_file].append({ + patches[in_file_relative].append({ + "file" : in_file, "detector" : "external-function", "start" : modify_loc_start + m.span()[0] + 1, "end" : modify_loc_start + m.span()[1], diff --git a/utils/slither_format/format_naming_convention.py b/utils/slither_format/format_naming_convention.py index 78330492a..6101f7fa3 100644 --- a/utils/slither_format/format_naming_convention.py +++ b/utils/slither_format/format_naming_convention.py @@ -15,45 +15,45 @@ class FormatNamingConvention: def format(slither, patches, elements): for element in elements: if (element['additional_fields']['target'] == "parameter"): - FormatNamingConvention.create_patch(slither, patches, element['additional_fields']['target'], element['name'], element['type_specific_fields']['parent']['name'], element['type_specific_fields']['parent']['type_specific_fields']['parent']['name'], element['source_mapping']['filename_absolute'],element['source_mapping']['start'],(element['source_mapping']['start']+element['source_mapping']['length'])) + FormatNamingConvention.create_patch(slither, patches, element['additional_fields']['target'], element['name'], element['type_specific_fields']['parent']['name'], element['type_specific_fields']['parent']['type_specific_fields']['parent']['name'], element['source_mapping']['filename_absolute'], element['source_mapping']['filename_relative'], element['source_mapping']['start'],(element['source_mapping']['start']+element['source_mapping']['length'])) elif (element['additional_fields']['target'] == "modifier" or element['additional_fields']['target'] == "function" or element['additional_fields']['target'] == "event" or element['additional_fields']['target'] == "variable" or element['additional_fields']['target'] == "variable_constant" or element['additional_fields']['target'] == "enum" or element['additional_fields']['target'] == "structure"): - FormatNamingConvention.create_patch(slither, patches, element['additional_fields']['target'], element['name'], element['name'], element['type_specific_fields']['parent']['name'], element['source_mapping']['filename_absolute'],element['source_mapping']['start'],(element['source_mapping']['start']+element['source_mapping']['length'])) + FormatNamingConvention.create_patch(slither, patches, element['additional_fields']['target'], element['name'], element['name'], element['type_specific_fields']['parent']['name'], element['source_mapping']['filename_absolute'], element['source_mapping']['filename_relative'], element['source_mapping']['start'],(element['source_mapping']['start']+element['source_mapping']['length'])) else: - FormatNamingConvention.create_patch(slither, patches, element['additional_fields']['target'], element['name'], element['name'], element['name'], element['source_mapping']['filename_absolute'],element['source_mapping']['start'],(element['source_mapping']['start']+element['source_mapping']['length'])) + FormatNamingConvention.create_patch(slither, patches, element['additional_fields']['target'], element['name'], element['name'], element['name'], element['source_mapping']['filename_absolute'], element['source_mapping']['filename_relative'], element['source_mapping']['start'],(element['source_mapping']['start']+element['source_mapping']['length'])) @staticmethod - def create_patch(slither, patches, _target, name, function_name, contract_name, in_file, modify_loc_start, modify_loc_end): + def create_patch(slither, patches, _target, name, function_name, contract_name, in_file, in_file_relative, modify_loc_start, modify_loc_end): if _target == "contract": - FormatNamingConvention.create_patch_contract_definition(slither, patches, name, in_file, modify_loc_start, modify_loc_end) - FormatNamingConvention.create_patch_contract_uses(slither, patches, name, in_file) + FormatNamingConvention.create_patch_contract_definition(slither, patches, name, in_file, in_file_relative, modify_loc_start, modify_loc_end) + FormatNamingConvention.create_patch_contract_uses(slither, patches, name, in_file, in_file_relative) elif _target == "structure": - FormatNamingConvention.create_patch_struct_definition(slither, patches, name, contract_name, in_file, modify_loc_start, modify_loc_end) - FormatNamingConvention.create_patch_struct_uses(slither, patches, name, contract_name, in_file) + FormatNamingConvention.create_patch_struct_definition(slither, patches, name, contract_name, in_file, in_file_relative, modify_loc_start, modify_loc_end) + FormatNamingConvention.create_patch_struct_uses(slither, patches, name, contract_name, in_file, in_file_relative) elif _target == "event": - FormatNamingConvention.create_patch_event_definition(slither, patches, name, contract_name, in_file, modify_loc_start, modify_loc_end) - FormatNamingConvention.create_patch_event_calls(slither, patches, name, contract_name, in_file) + FormatNamingConvention.create_patch_event_definition(slither, patches, name, contract_name, in_file, in_file_relative, modify_loc_start, modify_loc_end) + FormatNamingConvention.create_patch_event_calls(slither, patches, name, contract_name, in_file, in_file_relative) elif _target == "function": if name != contract_name: - FormatNamingConvention.create_patch_function_definition(slither, patches, name, contract_name, in_file, modify_loc_start, modify_loc_end) - FormatNamingConvention.create_patch_function_calls(slither, patches, name, contract_name, in_file) + FormatNamingConvention.create_patch_function_definition(slither, patches, name, contract_name, in_file, in_file_relative, modify_loc_start, modify_loc_end) + FormatNamingConvention.create_patch_function_calls(slither, patches, name, contract_name, in_file, in_file_relative) elif _target == "parameter": - FormatNamingConvention.create_patch_parameter_declaration(slither, patches, name, function_name, contract_name, in_file, modify_loc_start, modify_loc_end) - FormatNamingConvention.create_patch_parameter_uses(slither, patches, name, function_name, contract_name, in_file) + FormatNamingConvention.create_patch_parameter_declaration(slither, patches, name, function_name, contract_name, in_file, in_file_relative, modify_loc_start, modify_loc_end) + FormatNamingConvention.create_patch_parameter_uses(slither, patches, name, function_name, contract_name, in_file, in_file_relative) elif _target == "variable_constant" or _target == "variable": - FormatNamingConvention.create_patch_state_variable_declaration(slither, patches, _target, name, contract_name, in_file, modify_loc_start, modify_loc_end) - FormatNamingConvention.create_patch_state_variable_uses(slither, patches, _target, name, contract_name, in_file) + FormatNamingConvention.create_patch_state_variable_declaration(slither, patches, _target, name, contract_name, in_file, in_file_relative, modify_loc_start, modify_loc_end) + FormatNamingConvention.create_patch_state_variable_uses(slither, patches, _target, name, contract_name, in_file, in_file_relative) elif _target == "enum": - FormatNamingConvention.create_patch_enum_definition(slither, patches, name, contract_name, in_file, modify_loc_start, modify_loc_end) - FormatNamingConvention.create_patch_enum_uses(slither, patches, name, contract_name, in_file) + FormatNamingConvention.create_patch_enum_definition(slither, patches, name, contract_name, in_file, in_file_relative, modify_loc_start, modify_loc_end) + FormatNamingConvention.create_patch_enum_uses(slither, patches, name, contract_name, in_file, in_file_relative) elif _target == "modifier": - FormatNamingConvention.create_patch_modifier_definition(slither, patches, name, contract_name, in_file, modify_loc_start, modify_loc_end) - FormatNamingConvention.create_patch_modifier_uses(slither, patches, name, contract_name, in_file) + FormatNamingConvention.create_patch_modifier_definition(slither, patches, name, contract_name, in_file, in_file_relative, modify_loc_start, modify_loc_end) + FormatNamingConvention.create_patch_modifier_uses(slither, patches, name, contract_name, in_file, in_file_relative) else: logger.error(red("Unknown naming convention! " + _target)) sys.exit(-1) @staticmethod - def create_patch_contract_definition(slither, patches, name, in_file, modify_loc_start, modify_loc_end): + def create_patch_contract_definition(slither, patches, name, in_file, in_file_relative, modify_loc_start, modify_loc_end): for contract in slither.contracts: if contract.name == name: in_file_str = slither.source_code[in_file].encode('utf-8') @@ -63,20 +63,21 @@ class FormatNamingConvention: (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"contract"+r'(.*)'+name, r'\1'+"contract"+r'\2'+name.capitalize(), old_str_of_interest.decode('utf-8'), 1) if num_repl != 0: patch = { + "file" : in_file, "detector" : "naming-convention (contract definition)", "start":modify_loc_start, "end":modify_loc_start+m.span()[1], "old_string":old_str_of_interest.decode('utf-8'), "new_string":new_str_of_interest } - if not patch in patches[in_file]: - patches[in_file].append(patch) + if not patch in patches[in_file_relative]: + patches[in_file_relative].append(patch) else: logger.error(red("Could not find contract?!")) sys.exit(-1) @staticmethod - def create_patch_contract_uses(slither, patches, name, in_file): + def create_patch_contract_uses(slither, patches, name, in_file, in_file_relative): for contract in slither.contracts: if contract.name != name: in_file_str = slither.source_code[in_file].encode('utf-8') @@ -88,31 +89,33 @@ class FormatNamingConvention: old_str_of_interest = in_file_str[sv.source_mapping['start']:(sv.source_mapping['start']+sv.source_mapping['length'])] (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(),old_str_of_interest.decode('utf-8'), 1) patch = { + "file" : in_file, "detector" : "naming-convention (contract state variable)", "start" : sv.source_mapping['start'], "end" : sv.source_mapping['start'] + sv.source_mapping['length'], "old_string" : old_str_of_interest.decode('utf-8'), "new_string" : new_str_of_interest } - if not patch in patches[in_file]: - patches[in_file].append(patch) + if not patch in patches[in_file_relative]: + patches[in_file_relative].append(patch) # Check function+modifier locals+parameters+returns # To-do: Deep-check aggregate types (struct and mapping) fms = contract.functions + contract.modifiers for fm in fms: for v in fm.variables: if (str(v.type) == name): - old_str_of_interest = in_file_str[v.source_mapping['start']:(v.source_mapping['start']+v.source_mapping['length'])] - (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(),old_str_of_interest.decode('utf-8'), 1) + old_str_of_interest = in_file_str[v.source_mapping['start']:(v.source_mapping['start']+v.source_mapping['length'])].decode('utf-8').split('=')[0] + (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(),old_str_of_interest, 1) patch = { + "file" : in_file, "detector" : "naming-convention (contract function variable)", "start" : v.source_mapping['start'], - "end" : v.source_mapping['start'] + v.source_mapping['length'], - "old_string" : old_str_of_interest.decode('utf-8'), + "end" : v.source_mapping['start'] + len(old_str_of_interest), + "old_string" : old_str_of_interest, "new_string" : new_str_of_interest } - if not patch in patches[in_file]: - patches[in_file].append(patch) + if not patch in patches[in_file_relative]: + patches[in_file_relative].append(patch) # Check "new" expressions for creation of contract objects for function in contract.functions: for node in function.nodes: @@ -124,14 +127,15 @@ class FormatNamingConvention: (new_str_of_interest, num_repl) = re.subn("new"+r'(.*)'+name, "new"+r'\1'+name[0].upper()+name[1:], old_str_of_interest, 1) if num_repl != 0: patch = { + "file" : in_file, "detector" : "naming-convention (contract new object)", "start" : node.source_mapping['start'] + m.span()[0], "end" : node.source_mapping['start'] + m.span()[1], "old_string" : old_str_of_interest, "new_string" : new_str_of_interest } - if not patch in patches[in_file]: - patches[in_file].append(patch) + if not patch in patches[in_file_relative]: + patches[in_file_relative].append(patch) else: logger.error(red("Could not find new object?!")) sys.exit(-1) @@ -141,7 +145,7 @@ class FormatNamingConvention: continue @staticmethod - def create_patch_modifier_definition(slither, patches, name, contract_name, in_file, modify_loc_start, modify_loc_end): + def create_patch_modifier_definition(slither, patches, name, contract_name, in_file, in_file_relative, modify_loc_start, modify_loc_end): for contract in slither.contracts: if contract.name == contract_name: for modifier in contract.modifiers: @@ -153,20 +157,21 @@ class FormatNamingConvention: (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"modifier"+r'(.*)'+name, r'\1'+"modifier"+r'\2'+name[0].lower()+name[1:], old_str_of_interest.decode('utf-8'), 1) if num_repl != 0: patch = { + "file" : in_file, "detector" : "naming-convention (modifier definition)", "start" : modify_loc_start, "end" : modify_loc_start+m.span()[1], "old_string" : old_str_of_interest.decode('utf-8'), "new_string" : new_str_of_interest } - if not patch in patches[in_file]: - patches[in_file].append(patch) + if not patch in patches[in_file_relative]: + patches[in_file_relative].append(patch) else: logger.error(red("Could not find modifier?!")) sys.exit(-1) @staticmethod - def create_patch_modifier_uses(slither, patches, name, contract_name, in_file): + def create_patch_modifier_uses(slither, patches, name, contract_name, in_file, in_file_relative): for contract in slither.contracts: if (contract.name == contract_name): target_contract = contract @@ -180,45 +185,47 @@ class FormatNamingConvention: (new_str_of_interest, num_repl) = re.subn(name, name[0].lower()+name[1:],old_str_of_interest.decode('utf-8'),1) if num_repl != 0: patch = { + "file" : in_file, "detector" : "naming-convention (modifier uses)", "start" : int(function.parameters_src.source_mapping['start']), "end" : int(function.returns_src.source_mapping['start']), "old_string" : old_str_of_interest.decode('utf-8'), "new_string" : new_str_of_interest } - if not patch in patches[in_file]: - patches[in_file].append(patch) + if not patch in patches[in_file_relative]: + patches[in_file_relative].append(patch) else: logger.error(red("Could not find modifier name?!")) sys.exit(-1) @staticmethod - def create_patch_function_definition(slither, patches, name, contract_name, in_file, modify_loc_start, modify_loc_end): + def create_patch_function_definition(slither, patches, name, contract_name, in_file, in_file_relative, modify_loc_start, modify_loc_end): for contract in slither.contracts: if contract.name == contract_name: for function in contract.functions: if function.name == name: in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - m = re.match(r'(.*)'+"function"+r'(.*)'+name, old_str_of_interest.decode('utf-8')) + m = re.match(r'(.*)'+"function"+r'\s*'+name, old_str_of_interest.decode('utf-8')) old_str_of_interest = in_file_str[modify_loc_start:modify_loc_start+m.span()[1]] (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"function"+r'(.*)'+name, r'\1'+"function"+r'\2'+name[0].lower()+name[1:], old_str_of_interest.decode('utf-8'), 1) if num_repl != 0: patch = { + "file" : in_file, "detector" : "naming-convention (function definition)", "start" : modify_loc_start, "end" : modify_loc_start+m.span()[1], "old_string" : old_str_of_interest.decode('utf-8'), "new_string" : new_str_of_interest } - if not patch in patches[in_file]: - patches[in_file].append(patch) + if not patch in patches[in_file_relative]: + patches[in_file_relative].append(patch) else: logger.error(red("Could not find function?!")) sys.exit(-1) @staticmethod - def create_patch_function_calls(slither, patches, name, contract_name, in_file): + def create_patch_function_calls(slither, patches, name, contract_name, in_file, in_file_relative): for contract in slither.contracts: for function in contract.functions: for node in function.nodes: @@ -233,30 +240,32 @@ class FormatNamingConvention: fixed_function_name = called_function_name[0].lower() + called_function_name[1:] new_string = '.'.join(old_str_of_interest.decode('utf-8').split('.')[:-1]) + '.' + fixed_function_name patch = { + "file" : in_file, "detector" : "naming-convention (function calls)", "start" : external_call.source_mapping['start'], "end" : int(external_call.source_mapping['start']) + int(external_call.source_mapping['length']), "old_string" : old_str_of_interest.decode('utf-8'), "new_string" : new_string } - if not patch in patches[in_file]: - patches[in_file].append(patch) + if not patch in patches[in_file_relative]: + patches[in_file_relative].append(patch) for internal_call in node.internal_calls_as_expressions: if (str(internal_call.called) == name): in_file_str = slither.source_code[in_file].encode('utf-8') - old_str_of_interest = in_file_str[int(internal_call.source_mapping['start']):int(internal_call.source_mapping['start'])+int(internal_call.source_mapping['length'])] + old_str_of_interest = in_file_str[int(internal_call.source_mapping['start']):int(internal_call.source_mapping['start'])+int(internal_call.source_mapping['length'])].decode('utf-8').split('(')[0] patch = { + "file" : in_file, "detector" : "naming-convention (function calls)", "start" : internal_call.source_mapping['start'], - "end" : int(internal_call.source_mapping['start']) + int(internal_call.source_mapping['length']), - "old_string" : old_str_of_interest.decode('utf-8'), - "new_string" : old_str_of_interest.decode('utf-8')[0].lower()+old_str_of_interest.decode('utf-8')[1:] + "end" : int(internal_call.source_mapping['start']) + int(internal_call.source_mapping['length']) - len('('.join(in_file_str[int(internal_call.source_mapping['start']):int(internal_call.source_mapping['start'])+int(internal_call.source_mapping['length'])].decode('utf-8').split('(')[1:])) - 1, + "old_string" : old_str_of_interest, + "new_string" : old_str_of_interest[0].lower()+old_str_of_interest[1:] } - if not patch in patches[in_file]: - patches[in_file].append(patch) + if not patch in patches[in_file_relative]: + patches[in_file_relative].append(patch) @staticmethod - def create_patch_event_definition(slither, patches, name, contract_name, in_file, modify_loc_start, modify_loc_end): + def create_patch_event_definition(slither, patches, name, contract_name, in_file, in_file_relative, modify_loc_start, modify_loc_end): for contract in slither.contracts: if contract.name == contract_name: for event in contract.events: @@ -267,20 +276,21 @@ class FormatNamingConvention: (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"event"+r'(.*)'+event_name, r'\1'+"event"+r'\2'+event_name[0].capitalize()+event_name[1:], old_str_of_interest.decode('utf-8'), 1) if num_repl != 0: patch = { + "file" : in_file, "detector" : "naming-convention (event definition)", "start" : modify_loc_start, "end" : modify_loc_end, "old_string" : old_str_of_interest.decode('utf-8'), "new_string" : new_str_of_interest } - if not patch in patches[in_file]: - patches[in_file].append(patch) + if not patch in patches[in_file_relative]: + patches[in_file_relative].append(patch) else: logger.error(red("Could not find event?!")) sys.exit(-1) @staticmethod - def create_patch_event_calls(slither, patches, name, contract_name, in_file): + def create_patch_event_calls(slither, patches, name, contract_name, in_file, in_file_relative): event_name = name.split('(')[0] for contract in slither.contracts: if (contract.name == contract_name): @@ -294,17 +304,18 @@ class FormatNamingConvention: in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[int(call.source_mapping['start']):int(call.source_mapping['start'])+int(call.source_mapping['length'])] patch = { + "file" : in_file, "detector" : "naming-convention (event calls)", "start" : call.source_mapping['start'], "end" : int(call.source_mapping['start']) + int(call.source_mapping['length']), "old_string" : old_str_of_interest.decode('utf-8'), "new_string" : old_str_of_interest.decode('utf-8')[0].capitalize()+old_str_of_interest.decode('utf-8')[1:] } - if not patch in patches[in_file]: - patches[in_file].append(patch) + if not patch in patches[in_file_relative]: + patches[in_file_relative].append(patch) @staticmethod - def create_patch_parameter_declaration(slither, patches, name, function_name, contract_name, in_file, modify_loc_start, modify_loc_end): + def create_patch_parameter_declaration(slither, patches, name, function_name, contract_name, in_file, in_file_relative, modify_loc_start, modify_loc_end): for contract in slither.contracts: if contract.name == contract_name: for function in contract.functions: @@ -317,20 +328,21 @@ class FormatNamingConvention: (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+'_'+name[0].upper()+name[1:]+r'\2', old_str_of_interest.decode('utf-8'), 1) if num_repl != 0: patch = { + "file" : in_file, "detector" : "naming-convention (parameter declaration)", "start" : modify_loc_start, "end" : modify_loc_end, "old_string" : old_str_of_interest.decode('utf-8'), "new_string" : new_str_of_interest } - if not patch in patches[in_file]: - patches[in_file].append(patch) + if not patch in patches[in_file_relative]: + patches[in_file_relative].append(patch) else: logger.error(red("Could not find parameter declaration?!")) sys.exit(-1) @staticmethod - def create_patch_parameter_uses(slither, patches, name, function_name, contract_name, in_file): + def create_patch_parameter_uses(slither, patches, name, function_name, contract_name, in_file, in_file_relative): for contract in slither.contracts: if (contract.name == contract_name): for function in contract.functions: @@ -349,14 +361,15 @@ class FormatNamingConvention: (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+'_'+name[0].upper()+name[1:]+r'\2', old_str_of_interest.decode('utf-8'), 1) if num_repl != 0: patch = { + "file" : in_file, "detector" : "naming-convention (parameter uses)", "start" : modify_loc_start, "end" : modify_loc_end, "old_string" : old_str_of_interest.decode('utf-8'), "new_string" : new_str_of_interest } - if not patch in patches[in_file]: - patches[in_file].append(patch) + if not patch in patches[in_file_relative]: + patches[in_file_relative].append(patch) else: logger.error(red("Could not find parameter use?!")) sys.exit(-1) @@ -373,20 +386,21 @@ class FormatNamingConvention: (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+'_'+name[0].upper()+name[1:]+r'\2', old_str_of_interest_beyond_modifier_name, 1) if num_repl != 0: patch = { + "file" : in_file, "detector" : "naming-convention (parameter uses)", "start" : modifier.source_mapping['start'] + len(old_str_of_interest.decode('utf-8').split('(')[0]) + 1, "end" : modifier.source_mapping['start'] + modifier.source_mapping['length'], "old_string" : old_str_of_interest_beyond_modifier_name, "new_string" : new_str_of_interest } - if not patch in patches[in_file]: - patches[in_file].append(patch) + if not patch in patches[in_file_relative]: + patches[in_file_relative].append(patch) else: logger.error(red("Could not find parameter use in modifier?!")) sys.exit(-1) @staticmethod - def create_patch_state_variable_declaration(slither, patches, _target, name, contract_name, in_file, modify_loc_start, modify_loc_end): + def create_patch_state_variable_declaration(slither, patches, _target, name, contract_name, in_file, in_file_relative, modify_loc_start, modify_loc_end): for contract in slither.contracts: if (contract.name == contract_name): for var in contract.state_variables: @@ -400,17 +414,18 @@ class FormatNamingConvention: new_string = old_str_of_interest.decode('utf-8')[m.span()[0]:m.span()[1]] new_string = new_string[0].lower()+new_string[1:] patch = { + "file" : in_file, "detector" : "naming-convention (state variable declaration)", "start" : modify_loc_start+m.span()[0], "end" : modify_loc_start+m.span()[1], "old_string" : old_str_of_interest.decode('utf-8')[m.span()[0]:m.span()[1]], "new_string" : new_string } - if not patch in patches[in_file]: - patches[in_file].append(patch) + if not patch in patches[in_file_relative]: + patches[in_file_relative].append(patch) @staticmethod - def create_patch_state_variable_uses(slither, patches, _target, name, contract_name, in_file): + def create_patch_state_variable_uses(slither, patches, _target, name, contract_name, in_file, in_file_relative): # To-do: Check cross-contract state variable uses for contract in slither.contracts: if (contract.name == contract_name): @@ -433,17 +448,18 @@ class FormatNamingConvention: new_str_of_interest = old_str_of_interest.decode('utf-8') new_str_of_interest = new_str_of_interest[0].lower()+new_str_of_interest[1:] patch = { + "file" : in_file, "detector" : "naming-convention (state variable uses)", "start" : modify_loc_start, "end" : modify_loc_end, "old_string" : old_str_of_interest.decode('utf-8'), "new_string" : new_str_of_interest } - if not patch in patches[in_file]: - patches[in_file].append(patch) + if not patch in patches[in_file_relative]: + patches[in_file_relative].append(patch) @staticmethod - def create_patch_enum_definition(slither, patches, name, contract_name, in_file, modify_loc_start, modify_loc_end): + def create_patch_enum_definition(slither, patches, name, contract_name, in_file, in_file_relative, modify_loc_start, modify_loc_end): for contract in slither.contracts: if (contract.name == contract_name): for enum in contract.enums: @@ -453,20 +469,21 @@ class FormatNamingConvention: (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"enum"+r'(.*)'+name, r'\1'+"enum"+r'\2'+name[0].capitalize()+name[1:], old_str_of_interest.decode('utf-8'), 1) if num_repl != 0: patch = { + "file" : in_file, "detector" : "naming-convention (enum definition)", "start" : modify_loc_start, "end" : modify_loc_end, "old_string" : old_str_of_interest.decode('utf-8'), "new_string" : new_str_of_interest } - if not patch in patches[in_file]: - patches[in_file].append(patch) + if not patch in patches[in_file_relative]: + patches[in_file_relative].append(patch) else: logger.error(red("Could not find enum?!")) sys.exit(-1) @staticmethod - def create_patch_enum_uses(slither, patches, name, contract_name, in_file): + def create_patch_enum_uses(slither, patches, name, contract_name, in_file, in_file_relative): for contract in slither.contracts: if (contract.name == contract_name): target_contract = contract @@ -481,14 +498,15 @@ class FormatNamingConvention: old_str_of_interest = in_file_str[sv.source_mapping['start']:(sv.source_mapping['start']+sv.source_mapping['length'])] (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(),old_str_of_interest.decode('utf-8'), 1) patch = { + "file" : in_file, "detector" : "naming-convention (enum use)", "start" : sv.source_mapping['start'], "end" : sv.source_mapping['start'] + sv.source_mapping['length'], "old_string" : old_str_of_interest.decode('utf-8'), "new_string" : new_str_of_interest } - if not patch in patches[in_file]: - patches[in_file].append(patch) + if not patch in patches[in_file_relative]: + patches[in_file_relative].append(patch) # Check function+modifier locals+parameters+returns # To-do: Deep-check aggregate types (struct and mapping) fms = contract.functions + contract.modifiers @@ -499,14 +517,15 @@ class FormatNamingConvention: old_str_of_interest = in_file_str[v.source_mapping['start']:(v.source_mapping['start']+v.source_mapping['length'])] (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(),old_str_of_interest.decode('utf-8'), 1) patch = { + "file" : in_file, "detector" : "naming-convention (enum use)", "start" : v.source_mapping['start'], "end" : v.source_mapping['start'] + v.source_mapping['length'], "old_string" : old_str_of_interest.decode('utf-8'), "new_string" : new_str_of_interest } - if not patch in patches[in_file]: - patches[in_file].append(patch) + if not patch in patches[in_file_relative]: + patches[in_file_relative].append(patch) # Capture enum uses such as "num = numbers.ONE;" for function in contract.functions: for node in function.nodes: @@ -519,6 +538,7 @@ class FormatNamingConvention: (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name, r'\1'+name[0].upper()+name[1:], old_str_of_interest, 1) if num_repl != 0: patch = { + "file" : in_file, "detector" : "naming-convention (enum use)", "start" : node.source_mapping['start'] + len(in_file_str[node.source_mapping['start']:(node.source_mapping['start']+node.source_mapping['length'])].decode('utf-8').split('=')[0]) + 1 + m.span()[0], "end" : node.source_mapping['start'] + len(in_file_str[node.source_mapping['star\ @@ -526,15 +546,15 @@ t']:(node.source_mapping['start']+node.source_mapping['length'])].decode('utf-8' "old_string" : old_str_of_interest, "new_string" : new_str_of_interest } - if not patch in patches[in_file]: - patches[in_file].append(patch) + if not patch in patches[in_file_relative]: + patches[in_file_relative].append(patch) else: logger.error(red("Could not find new object?!")) sys.exit(-1) # To-do: Check any other place/way where enum type is used @staticmethod - def create_patch_struct_definition(slither, patches, name, contract_name, in_file, modify_loc_start, modify_loc_end): + def create_patch_struct_definition(slither, patches, name, contract_name, in_file, in_file_relative, modify_loc_start, modify_loc_end): for contract in slither.contracts: if (contract.name == contract_name): for struct in contract.structures: @@ -544,20 +564,21 @@ t']:(node.source_mapping['start']+node.source_mapping['length'])].decode('utf-8' (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"struct"+r'(.*)'+name, r'\1'+"struct"+r'\2'+name[0].capitalize()+name[1:], old_str_of_interest.decode('utf-8'), 1) if num_repl != 0: patch = { + "file" : in_file, "detector" : "naming-convention (struct definition)", "start" : modify_loc_start, "end" : modify_loc_end, "old_string" : old_str_of_interest.decode('utf-8'), "new_string" : new_str_of_interest } - if not patch in patches[in_file]: - patches[in_file].append(patch) + if not patch in patches[in_file_relative]: + patches[in_file_relative].append(patch) else: logger.error(red("Could not find struct?!")) sys.exit(-1) @staticmethod - def create_patch_struct_uses(slither, patches, name, contract_name, in_file): + def create_patch_struct_uses(slither, patches, name, contract_name, in_file, in_file_relative): for contract in slither.contracts: if (contract.name == contract_name): target_contract = contract @@ -572,14 +593,15 @@ t']:(node.source_mapping['start']+node.source_mapping['length'])].decode('utf-8' old_str_of_interest = in_file_str[sv.source_mapping['start']:(sv.source_mapping['start']+sv.source_mapping['length'])] (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(),old_str_of_interest.decode('utf-8'), 1) patch = { + "file" : in_file, "detector" : "naming-convention (struct use)", "start" : sv.source_mapping['start'], "end" : sv.source_mapping['start'] + sv.source_mapping['length'], "old_string" : old_str_of_interest.decode('utf-8'), "new_string" : new_str_of_interest } - if not patch in patches[in_file]: - patches[in_file].append(patch) + if not patch in patches[in_file_relative]: + patches[in_file_relative].append(patch) # Check function+modifier locals+parameters+returns # To-do: Deep-check aggregate types (struct and mapping) fms = contract.functions + contract.modifiers @@ -589,12 +611,13 @@ t']:(node.source_mapping['start']+node.source_mapping['length'])].decode('utf-8' old_str_of_interest = in_file_str[v.source_mapping['start']:(v.source_mapping['start']+v.source_mapping['length'])] (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(),old_str_of_interest.decode('utf-8'), 1) patch = { + "file" : in_file, "detector" : "naming-convention (struct use)", "start" : v.source_mapping['start'], "end" : v.source_mapping['start'] + v.source_mapping['length'], "old_string" : old_str_of_interest.decode('utf-8'), "new_string" : new_str_of_interest } - if not patch in patches[in_file]: - patches[in_file].append(patch) + if not patch in patches[in_file_relative]: + patches[in_file_relative].append(patch) # To-do: Check any other place/way where struct type is used (e.g. typecast) diff --git a/utils/slither_format/format_pragma.py b/utils/slither_format/format_pragma.py index 013e04ed3..4f486e656 100644 --- a/utils/slither_format/format_pragma.py +++ b/utils/slither_format/format_pragma.py @@ -1,4 +1,4 @@ -import re, logging +import re, logging, sys from slither.utils.colors import red, yellow, set_colorization_enabled logging.basicConfig(level=logging.INFO) @@ -25,7 +25,7 @@ class FormatPragma: versions_used.append(''.join(element['type_specific_fields']['directive'][1:])) solc_version_replace = FormatPragma.analyse_versions(versions_used) for element in elements: - FormatPragma.create_patch(slither, patches, element['source_mapping']['filename_absolute'], solc_version_replace, element['source_mapping']['start'], element['source_mapping']['start'] + element['source_mapping']['length']) + FormatPragma.create_patch(slither, patches, element['source_mapping']['filename_absolute'], element['source_mapping']['filename_relative'], solc_version_replace, element['source_mapping']['start'], element['source_mapping']['start'] + element['source_mapping']['length']) @staticmethod def analyse_versions(used_solc_versions): @@ -62,10 +62,11 @@ class FormatPragma: return "pragma solidity " + FormatPragma.REPLACEMENT_VERSIONS[1] + ';' @staticmethod - def create_patch(slither, patches, in_file, pragma, modify_loc_start, modify_loc_end): + def create_patch(slither, patches, in_file, in_file_relative, pragma, modify_loc_start, modify_loc_end): in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - patches[in_file].append({ + patches[in_file_relative].append({ + "file" : in_file, "detector" : "pragma", "start" : modify_loc_start, "end" : modify_loc_end, diff --git a/utils/slither_format/format_solc_version.py b/utils/slither_format/format_solc_version.py index e27ff60a5..73bb5c323 100644 --- a/utils/slither_format/format_solc_version.py +++ b/utils/slither_format/format_solc_version.py @@ -22,7 +22,7 @@ class FormatSolcVersion: def format(slither, patches, elements): for element in elements: solc_version_replace = FormatSolcVersion.determine_solc_version_replacement(''.join(element['type_specific_fields']['directive'][1:])) - FormatSolcVersion.create_patch(slither, patches, element['source_mapping']['filename_absolute'], solc_version_replace, element['source_mapping']['start'], element['source_mapping']['start'] + element['source_mapping']['length']) + FormatSolcVersion.create_patch(slither, patches, element['source_mapping']['filename_absolute'], element['source_mapping']['filename_relative'], solc_version_replace, element['source_mapping']['start'], element['source_mapping']['start'] + element['source_mapping']['length']) @staticmethod def determine_solc_version_replacement(used_solc_version): @@ -48,10 +48,11 @@ class FormatSolcVersion: return "pragma solidity " + FormatSolcVersion.REPLACEMENT_VERSIONS[1] + ';' @staticmethod - def create_patch(slither, patches, in_file, solc_version, modify_loc_start, modify_loc_end): + def create_patch(slither, patches, in_file, in_file_relative, solc_version, modify_loc_start, modify_loc_end): in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - patches[in_file].append({ + patches[in_file_relative].append({ + "file" : in_file, "detector" : "solc-version", "start" : modify_loc_start, "end" : modify_loc_end, diff --git a/utils/slither_format/format_unused_state.py b/utils/slither_format/format_unused_state.py index 4a3e8c970..1f8921b21 100644 --- a/utils/slither_format/format_unused_state.py +++ b/utils/slither_format/format_unused_state.py @@ -4,13 +4,14 @@ class FormatUnusedState: def format(slither, patches, elements): for element in elements: if element['type'] == "variable": - FormatUnusedState.create_patch(slither, patches, element['source_mapping']['filename_absolute'], element['source_mapping']['start']) + FormatUnusedState.create_patch(slither, patches, element['source_mapping']['filename_absolute'], element['source_mapping']['filename_relative'], element['source_mapping']['start']) @staticmethod - def create_patch(slither, patches, in_file, modify_loc_start): + def create_patch(slither, patches, in_file, in_file_relative, modify_loc_start): in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:] - patches[in_file].append({ + patches[in_file_relative].append({ + "file" : in_file, "detector" : "unused-state", "start" : modify_loc_start, "end" : modify_loc_start + len(old_str_of_interest.decode('utf-8').partition(';')[0]) + 1, diff --git a/utils/slither_format/slither_format.py b/utils/slither_format/slither_format.py index a97bfcd34..5a75d3a53 100644 --- a/utils/slither_format/slither_format.py +++ b/utils/slither_format/slither_format.py @@ -1,4 +1,4 @@ -import sys, re, logging +import sys, re, logging, subprocess from collections import defaultdict from slither.utils.colors import red, yellow, set_colorization_enabled from slither.detectors.variables.unused_state_variables import UnusedStateVars @@ -52,7 +52,7 @@ def slither_format(args, slither): print_patches_json(number_of_slither_results, patches) if args.verbose_test: print_patches(number_of_slither_results, patches) - apply_patches(slither, patches) + generate_patch_files(slither, patches) def sort_and_flag_overlapping_patches(patches): for file in patches: @@ -65,8 +65,10 @@ def sort_and_flag_overlapping_patches(patches): patches[file][j+1] = patches[file][j] patches[file][j] = temp # Overlap check - if (int(patches[file][j]['start']) >= int(patches[file][j+1]['start']) and - int(patches[file][j]['start']) <= int(patches[file][j+1]['end'])): + if ((int(patches[file][j]['start']) >= int(patches[file][j+1]['start']) and + int(patches[file][j]['start']) <= int(patches[file][j+1]['end'])) or + (int(patches[file][j+1]['start']) >= int(patches[file][j]['start']) and + int(patches[file][j+1]['start']) <= int(patches[file][j]['end']))): patches[file][j]['overlaps'] = "Yes" patches[file][j+1]['overlaps'] = "Yes" @@ -87,10 +89,11 @@ def prune_overlapping_patches(args, patches): non_overlapping_patches = [patch for patch in patches[file] if not is_overlap_patch(args, patch)] patches[file] = non_overlapping_patches -def apply_patches(slither, patches): +def generate_patch_files(slither, patches): for file in patches: _in_file = file - in_file_str = slither.source_code[_in_file].encode('utf-8') + if patches[file]: + in_file_str = slither.source_code[patches[file][0]['file']].encode('utf-8') out_file_str = "" for i in range(len(patches[file])): if i != 0: @@ -103,6 +106,11 @@ def apply_patches(slither, patches): 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") + 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)) diff --git a/utils/slither_format/tests/test_detector_combinations.py b/utils/slither_format/tests/test_detector_combinations.py index c70f7e6b7..6ea90ccf0 100644 --- a/utils/slither_format/tests/test_detector_combinations.py +++ b/utils/slither_format/tests/test_detector_combinations.py @@ -26,11 +26,12 @@ class TestDetectorCombinations(unittest.TestCase): errFD1_lines[i] = errFD1_lines[i].strip() self.assertTrue(os.path.isfile(self.testFilePath1+".format"),"Patched .format file is not created?!") self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Number of Slither results: 12"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Number of patches: 19"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Overlapping patch won't be applied!"), 2) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Number of patches: 18"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Overlapping patch won't be applied!"), 3) self.assertEqual(errFD1_lines.count("INFO:Slither.Format:xDetector: unused-state"), 1) self.assertEqual(errFD1_lines.count("INFO:Slither.Format:xDetector: constable-states"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Detector: naming-convention (state variable declaration)"), 2) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:xDetector: naming-convention (state variable declaration)"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Detector: naming-convention (state variable declaration)"), 1) self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Detector: naming-convention (state variable uses)"), 3) self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Detector: naming-convention (parameter declaration)"), 4) self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Detector: naming-convention (parameter uses)"), 6) diff --git a/utils/slither_format/tests/test_naming_convention.py b/utils/slither_format/tests/test_naming_convention.py index 310b53a0b..19ee2320d 100644 --- a/utils/slither_format/tests/test_naming_convention.py +++ b/utils/slither_format/tests/test_naming_convention.py @@ -136,10 +136,10 @@ class TestNamingConvention(unittest.TestCase): self.assertEqual(errFD1_lines.count("INFO:Slither.Format:New string: One"), 1) self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 646"), 1) self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 649"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Old string: one r = new one()"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:New string: One r = new one()"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Old string: one r"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:New string: One r"), 1) self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 773"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 790"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 779"), 1) self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Old string: one q"), 1) self.assertEqual(errFD1_lines.count("INFO:Slither.Format:New string: One q"), 1) self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 871"), 1) @@ -306,10 +306,10 @@ class TestNamingConvention(unittest.TestCase): self.assertEqual(errFD6_lines.count("INFO:Slither.Format:New string: function foobar"), 1) self.assertEqual(errFD6_lines.count("INFO:Slither.Format:Location start: 189"), 1) self.assertEqual(errFD6_lines.count("INFO:Slither.Format:Location end: 204"), 1) - self.assertEqual(errFD6_lines.count("INFO:Slither.Format:Old string: Foobar(10)"), 1) - self.assertEqual(errFD6_lines.count("INFO:Slither.Format:New string: foobar(10)"), 1) + self.assertEqual(errFD6_lines.count("INFO:Slither.Format:Old string: Foobar"), 1) + self.assertEqual(errFD6_lines.count("INFO:Slither.Format:New string: foobar"), 1) self.assertEqual(errFD6_lines.count("INFO:Slither.Format:Location start: 136"), 1) - self.assertEqual(errFD6_lines.count("INFO:Slither.Format:Location end: 146"), 1) + self.assertEqual(errFD6_lines.count("INFO:Slither.Format:Location end: 142"), 1) self.assertEqual(errFD6_lines.count("INFO:Slither.Format:Old string: a.Foobar(10)"), 1) self.assertEqual(errFD6_lines.count("INFO:Slither.Format:New string: a.foobar(10)"), 1) self.assertEqual(errFD6_lines.count("INFO:Slither.Format:Location start: 516"), 1) diff --git a/utils/slither_format/tests/test_solc_version.py b/utils/slither_format/tests/test_solc_version.py index 45b51d95c..3f41f981e 100644 --- a/utils/slither_format/tests/test_solc_version.py +++ b/utils/slither_format/tests/test_solc_version.py @@ -29,7 +29,9 @@ class TestSolcVersion(unittest.TestCase): outFD3 = open(self.testFilePath3+".out","w") errFD3 = open(self.testFilePath3+".err","w") - p3 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose-test','--detect','solc-version',self.testFilePath3], stdout=outFD3,stderr=errFD3) + my_env = os.environ.copy() + my_env["SOLC_VERSION"] = "0.4.24" + p3 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose-test','--detect','solc-version',self.testFilePath3], stdout=outFD3,stderr=errFD3, env=my_env) p3.wait() outFD3.close() errFD3.close() From b9962c0d96f3d55b9a7e6d50cf741464896ed4ad Mon Sep 17 00:00:00 2001 From: rajeevgopalakrishna Date: Fri, 24 May 2019 07:45:02 +0530 Subject: [PATCH 035/223] Adds five more real-world non-trivial contracts for testing. --- ...67c080e9d511a34d36152c0_MultiSigWallet.sol | 367 +++ ...64061dd23f8209f804a3b8ad2f2_FoMo3Dlong.sol | 2058 +++++++++++++++++ ...15a7d984b8c71c15e82b7_EnclavesDEXProxy.sol | 286 +++ ...d8f85f41cfb6de49b9db29_BancorConverter.sol | 1011 ++++++++ ...ea7f106ecbd1850e406adc41b51_OceanToken.sol | 454 ++++ 5 files changed, 4176 insertions(+) create mode 100644 utils/slither_format/tests/real_world/0x05cf67329a262818e67c080e9d511a34d36152c0_MultiSigWallet.sol create mode 100644 utils/slither_format/tests/real_world/0x5d0d76787d9d564061dd23f8209f804a3b8ad2f2_FoMo3Dlong.sol create mode 100644 utils/slither_format/tests/real_world/0xbf45f4280cfbe7c2d2515a7d984b8c71c15e82b7_EnclavesDEXProxy.sol create mode 100644 utils/slither_format/tests/real_world/0xc6725ae749677f21e4d8f85f41cfb6de49b9db29_BancorConverter.sol create mode 100644 utils/slither_format/tests/real_world/0xf5ed2dc77f0d1ea7f106ecbd1850e406adc41b51_OceanToken.sol diff --git a/utils/slither_format/tests/real_world/0x05cf67329a262818e67c080e9d511a34d36152c0_MultiSigWallet.sol b/utils/slither_format/tests/real_world/0x05cf67329a262818e67c080e9d511a34d36152c0_MultiSigWallet.sol new file mode 100644 index 000000000..53465564c --- /dev/null +++ b/utils/slither_format/tests/real_world/0x05cf67329a262818e67c080e9d511a34d36152c0_MultiSigWallet.sol @@ -0,0 +1,367 @@ +pragma solidity ^0.4.15; + +// From https://github.com/ConsenSys/MultiSigWallet/blob/master/contracts/solidity/MultiSigWallet.sol @ e3240481928e9d2b57517bd192394172e31da487 + +/// @title Multisignature wallet - Allows multiple parties to agree on transactions before execution. +/// @author Stefan George - <[email protected]> +contract MultiSigWallet { + + uint constant public MAX_OWNER_COUNT = 5; + + event Confirmation(address indexed sender, uint indexed transactionId); + event Revocation(address indexed sender, uint indexed transactionId); + event Submission(uint indexed transactionId); + event Execution(uint indexed transactionId); + event ExecutionFailure(uint indexed transactionId); + event Deposit(address indexed sender, uint value); + event OwnerAddition(address indexed owner); + event OwnerRemoval(address indexed owner); + event RequirementChange(uint required); + + mapping (uint => Transaction) public transactions; + mapping (uint => mapping (address => bool)) public confirmations; + mapping (address => bool) public isOwner; + address[] public owners; + uint public required; + uint public transactionCount; + + struct Transaction { + address destination; + uint value; + bytes data; + bool executed; + } + + modifier onlyWallet() { + if (msg.sender != address(this)) + throw; + _; + } + + modifier ownerDoesNotExist(address owner) { + if (isOwner[owner]) + throw; + _; + } + + modifier ownerExists(address owner) { + if (!isOwner[owner]) + throw; + _; + } + + modifier transactionExists(uint transactionId) { + if (transactions[transactionId].destination == 0) + throw; + _; + } + + modifier confirmed(uint transactionId, address owner) { + if (!confirmations[transactionId][owner]) + throw; + _; + } + + modifier notConfirmed(uint transactionId, address owner) { + if (confirmations[transactionId][owner]) + throw; + _; + } + + modifier notExecuted(uint transactionId) { + if (transactions[transactionId].executed) + throw; + _; + } + + modifier notNull(address _address) { + if (_address == 0) + throw; + _; + } + + modifier validRequirement(uint ownerCount, uint _required) { + if ( ownerCount > MAX_OWNER_COUNT + || _required > ownerCount + || _required == 0 + || ownerCount == 0) + throw; + _; + } + + /// @dev Fallback function allows to deposit ether. + function() + payable + { + if (msg.value > 0) + Deposit(msg.sender, msg.value); + } + + /* + * Public functions + */ + /// @dev Contract constructor sets initial owners and required number of confirmations. + function MultiSigWallet() + public + { + address owner1 = address(0x5117afB03e83d180D0059a1Ad733F954220D2734); + address owner2 = address(0x4F9049886d8087c7549224383075ffbb3dF2b7a0); + address owner3 = address(0x4E63227fcFF602b3Fa9e6F4e86b33194f04236B1); + owners.push(address(owner1)); + owners.push(address(owner2)); + owners.push(address(owner3)); + isOwner[owner1] = true; + isOwner[owner2] = true; + isOwner[owner3] = true; + required = 3; + } + + /// @dev Allows to add a new owner. Transaction has to be sent by wallet. + /// @param owner Address of new owner. + function addOwner(address owner) + public + onlyWallet + ownerDoesNotExist(owner) + notNull(owner) + validRequirement(owners.length + 1, required) + { + isOwner[owner] = true; + owners.push(owner); + OwnerAddition(owner); + } + + /// @dev Allows to remove an owner. Transaction has to be sent by wallet. + /// @param owner Address of owner. + function removeOwner(address owner) + public + onlyWallet + ownerExists(owner) + { + isOwner[owner] = false; + for (uint i=0; i owners.length) + changeRequirement(owners.length); + OwnerRemoval(owner); + } + + /// @dev Allows to replace an owner with a new owner. Transaction has to be sent by wallet. + /// @param owner Address of owner to be replaced. + /// @param owner Address of new owner. + function replaceOwner(address owner, address newOwner) + public + onlyWallet + ownerExists(owner) + ownerDoesNotExist(newOwner) + { + for (uint i=0; i 0); // Solidity automatically throws when dividing by 0 + uint256 c = a / b; + // assert(a == b * c + a % b); // There is no case in which this doesn't hold + return c; + } + + /** + * @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend). + */ + function sub(uint256 a, uint256 b) + internal + pure + returns (uint256) + { + require(b <= a, "SafeMath sub failed"); + return a - b; + } + + /** + * @dev Adds two numbers, throws on overflow. + */ + function add(uint256 a, uint256 b) + internal + pure + returns (uint256 c) + { + c = a + b; + require(c >= a, "SafeMath add failed"); + return c; + } + + /** + * @dev gives square root of given x. + */ + function sqrt(uint256 x) + internal + pure + returns (uint256 y) + { + uint256 z = ((add(x,1)) / 2); + y = x; + while (z < y) + { + y = z; + z = ((add((x / z),z)) / 2); + } + } + + /** + * @dev gives square. multiplies x by x + */ + function sq(uint256 x) + internal + pure + returns (uint256) + { + return (mul(x,x)); + } + + /** + * @dev x to the power of y + */ + function pwr(uint256 x, uint256 y) + internal + pure + returns (uint256) + { + if (x==0) + return (0); + else if (y==0) + return (1); + else + { + uint256 z = x; + for (uint256 i=1; i < y; i++) + z = mul(z,x); + return (z); + } + } +} + +// File: contracts\library\UintCompressor.sol + +/** +* @title -UintCompressor- v0.1.9 +* ┌┬┐┌─┐┌─┐┌┬┐ ╦╦ ╦╔═╗╔╦╗ ┌─┐┬─┐┌─┐┌─┐┌─┐┌┐┌┌┬┐┌─┐ +* │ ├┤ ├─┤│││ ║║ ║╚═╗ ║ ├─┘├┬┘├┤ └─┐├┤ │││ │ └─┐ +* ┴ └─┘┴ ┴┴ ┴ ╚╝╚═╝╚═╝ ╩ ┴ ┴└─└─┘└─┘└─┘┘└┘ ┴ └─┘ +* _____ _____ +* (, / /) /) /) (, / /) /) +* ┌─┐ / _ (/_ // // / _ // _ __ _(/ +* ├─┤ ___/___(/_/(__(_/_(/_(/_ ___/__/_)_(/_(_(_/ (_(_(_ +* ┴ ┴ / / .-/ _____ (__ / +* (__ / (_/ (, / /)™ +* / __ __ __ __ _ __ __ _ _/_ _ _(/ +* ┌─┐┬─┐┌─┐┌┬┐┬ ┬┌─┐┌┬┐ /__/ (_(__(_)/ (_/_)_(_)/ (_(_(_(__(/_(_(_ +* ├─┘├┬┘│ │ │││ ││ │ (__ / .-/ © Jekyll Island Inc. 2018 +* ┴ ┴└─└─┘─┴┘└─┘└─┘ ┴ (_/ +* _ _ __ __ _ ____ ___ __ _ _ ____ ____ ____ ____ ____ __ ____ +*===/ )( \ ( ) ( ( \(_ _)===/ __) / \ ( \/ )( _ \( _ \( __)/ ___)/ ___) / \ ( _ \===* +* ) \/ ( )( / / )( ( (__ ( O )/ \/ \ ) __/ ) / ) _) \___ \\___ \( O ) ) / +*===\____/ (__) \_)__) (__)====\___) \__/ \_)(_/(__) (__\_)(____)(____/(____/ \__/ (__\_)===* +* +* ╔═╗┌─┐┌┐┌┌┬┐┬─┐┌─┐┌─┐┌┬┐ ╔═╗┌─┐┌┬┐┌─┐ ┌──────────┐ +* ║ │ ││││ │ ├┬┘├─┤│ │ ║ │ │ ││├┤ │ Inventor │ +* ╚═╝└─┘┘└┘ ┴ ┴└─┴ ┴└─┘ ┴ ╚═╝└─┘─┴┘└─┘ └──────────┘ +*/ + +library UintCompressor { + using SafeMath for *; + + function insert(uint256 _Var, uint256 _Include, uint256 _Start, uint256 _End) + internal + pure + returns(uint256) + { + // check conditions + require(_End < 77 && _Start < 77, "start/end must be less than 77"); + require(_End >= _Start, "end must be >= start"); + + // format our start/end points + _End = exponent(_End).mul(10); + _Start = exponent(_Start); + + // check that the include data fits into its segment + require(_Include < (_End / _Start)); + + // build middle + if (_Include > 0) + _Include = _Include.mul(_Start); + + return((_Var.sub((_Var / _Start).mul(_Start))).add(_Include).add((_Var / _End).mul(_End))); + } + + function extract(uint256 _Input, uint256 _Start, uint256 _End) + internal + pure + returns(uint256) + { + // check conditions + require(_End < 77 && _Start < 77, "start/end must be less than 77"); + require(_End >= _Start, "end must be >= start"); + + // format our start/end points + _End = exponent(_End).mul(10); + _Start = exponent(_Start); + + // return requested section + return((((_Input / _Start).mul(_Start)).sub((_Input / _End).mul(_End))) / _Start); + } + + function exponent(uint256 _Position) + private + pure + returns(uint256) + { + return((10).pwr(_Position)); + } +} + +// File: contracts\library\NameFilter.sol + +/** +* @title -Name Filter- v0.1.9 +* ┌┬┐┌─┐┌─┐┌┬┐ ╦╦ ╦╔═╗╔╦╗ ┌─┐┬─┐┌─┐┌─┐┌─┐┌┐┌┌┬┐┌─┐ +* │ ├┤ ├─┤│││ ║║ ║╚═╗ ║ ├─┘├┬┘├┤ └─┐├┤ │││ │ └─┐ +* ┴ └─┘┴ ┴┴ ┴ ╚╝╚═╝╚═╝ ╩ ┴ ┴└─└─┘└─┘└─┘┘└┘ ┴ └─┘ +* _____ _____ +* (, / /) /) /) (, / /) /) +* ┌─┐ / _ (/_ // // / _ // _ __ _(/ +* ├─┤ ___/___(/_/(__(_/_(/_(/_ ___/__/_)_(/_(_(_/ (_(_(_ +* ┴ ┴ / / .-/ _____ (__ / +* (__ / (_/ (, / /)™ +* / __ __ __ __ _ __ __ _ _/_ _ _(/ +* ┌─┐┬─┐┌─┐┌┬┐┬ ┬┌─┐┌┬┐ /__/ (_(__(_)/ (_/_)_(_)/ (_(_(_(__(/_(_(_ +* ├─┘├┬┘│ │ │││ ││ │ (__ / .-/ © Jekyll Island Inc. 2018 +* ┴ ┴└─└─┘─┴┘└─┘└─┘ ┴ (_/ +* _ __ _ ____ ____ _ _ _____ ____ ___ +*=============| |\ | / /\ | |\/| | |_ =====| |_ | | | | | | | |_ | |_)==============* +*=============|_| \| /_/--\ |_| | |_|__=====|_| |_| |_|__ |_| |_|__ |_| \==============* +* +* ╔═╗┌─┐┌┐┌┌┬┐┬─┐┌─┐┌─┐┌┬┐ ╔═╗┌─┐┌┬┐┌─┐ ┌──────────┐ +* ║ │ ││││ │ ├┬┘├─┤│ │ ║ │ │ ││├┤ │ Inventor │ +* ╚═╝└─┘┘└┘ ┴ ┴└─┴ ┴└─┘ ┴ ╚═╝└─┘─┴┘└─┘ └──────────┘ +*/ + +library NameFilter { + /** + * @dev filters name strings + * -converts uppercase to lower case. + * -makes sure it does not start/end with a space + * -makes sure it does not contain multiple spaces in a row + * -cannot be only numbers + * -cannot start with 0x + * -restricts characters to A-Z, a-z, 0-9, and space. + * @return reprocessed string in bytes32 format + */ + function nameFilter(string _Input) + internal + + returns(bytes32) + { + bytes memory _temp = bytes(_Input); + uint256 _length = _temp.length; + + //sorry limited to 32 characters + require (_length <= 32 && _length > 0, "string must be between 1 and 32 characters"); + // make sure it doesnt start with or end with space + require(_temp[0] != 0x20 && _temp[_length-1] != 0x20, "string cannot start or end with space"); + // make sure first two characters are not 0x + if (_temp[0] == 0x30) + { + require(_temp[1] != 0x78, "string cannot start with 0x"); + require(_temp[1] != 0x58, "string cannot start with 0X"); + } + + // create a bool to track if we have a non number character + bool _hasNonNumber; + + // convert & check + for (uint256 i = 0; i < _length; i++) + { + // if its uppercase A-Z + if (_temp[i] > 0x40 && _temp[i] < 0x5b) + { + // convert to lower case a-z + _temp[i] = byte(uint(_temp[i]) + 32); + + // we have a non number + if (_hasNonNumber == false) + _hasNonNumber = true; + } else { + require + ( + // require character is a space + _temp[i] == 0x20 || + // OR lowercase a-z + (_temp[i] > 0x60 && _temp[i] < 0x7b) || + // or 0-9 + (_temp[i] > 0x2f && _temp[i] < 0x3a), + "string contains invalid characters" + ); + // make sure theres not 2x spaces in a row + if (_temp[i] == 0x20) + require( _temp[i+1] != 0x20, "string cannot contain consecutive spaces"); + + // see if we have a character other than a number + if (_hasNonNumber == false && (_temp[i] < 0x30 || _temp[i] > 0x39)) + _hasNonNumber = true; + } + } + + require(_hasNonNumber == true, "string cannot be only numbers"); + + bytes32 _ret; + assembly { + _ret := mload(add(_temp, 32)) + } + return (_ret); + } +} + +// File: contracts\library\F3DKeysCalcLong.sol + +//============================================================================== +// | _ _ _ | _ . +// |<(/_\/ (_(_||(_ . +//=======/====================================================================== +library F3DKeysCalcLong { + using SafeMath for *; + /** + * @dev calculates number of keys received given X eth + * _curEth current amount of eth in contract + * _newEth eth being spent + * @return amount of ticket purchased + */ + function keysRec(uint256 _CurEth, uint256 _NewEth) + internal + pure + returns (uint256) + { + return(keys((_CurEth).add(_NewEth)).sub(keys(_CurEth))); + } + + /** + * @dev calculates amount of eth received if you sold X keys + * _curKeys current amount of keys that exist + * _sellKeys amount of keys you wish to sell + * @return amount of eth received + */ + function ethRec(uint256 _CurKeys, uint256 _SellKeys) + internal + pure + returns (uint256) + { + return((eth(_CurKeys)).sub(eth(_CurKeys.sub(_SellKeys)))); + } + + /** + * @dev calculates how many keys would exist with given an amount of eth + * _eth eth "in contract" + * @return number of keys that would exist + */ + function keys(uint256 _Eth) + internal + pure + returns(uint256) + { + return ((((((_Eth).mul(1000000000000000000)).mul(312500000000000000000000000)).add(5624988281256103515625000000000000000000000000000000000000000000)).sqrt()).sub(74999921875000000000000000000000)) / (156250000); + } + + /** + * @dev calculates how much eth would be in contract given a number of keys + * _keys number of keys "in contract" + * @return eth that would exists + */ + function eth(uint256 _Keys) + internal + pure + returns(uint256) + { + return ((78125000).mul(_Keys.sq()).add(((149999843750000).mul(_Keys.mul(1000000000000000000))) / (2))) / ((1000000000000000000).sq()); + } +} + +// File: contracts\library\F3Ddatasets.sol + +//============================================================================== +// __|_ _ __|_ _ . +// _\ | | |_|(_ | _\ . +//============================================================================== +library F3Ddatasets { + //compressedData key + // [76-33][32][31][30][29][28-18][17][16-6][5-3][2][1][0] + // 0 - new player (bool) + // 1 - joined round (bool) + // 2 - new leader (bool) + // 3-5 - air drop tracker (uint 0-999) + // 6-16 - round end time + // 17 - winnerTeam + // 18 - 28 timestamp + // 29 - team + // 30 - 0 = reinvest (round), 1 = buy (round), 2 = buy (ico), 3 = reinvest (ico) + // 31 - airdrop happened bool + // 32 - airdrop tier + // 33 - airdrop amount won + //compressedIDs key + // [77-52][51-26][25-0] + // 0-25 - pID + // 26-51 - winPID + // 52-77 - rID + struct EventReturns { + uint256 compressedData; + uint256 compressedIDs; + address winnerAddr; // winner address + bytes32 winnerName; // winner name + uint256 amountWon; // amount won + uint256 newPot; // amount in new pot + uint256 P3DAmount; // amount distributed to p3d + uint256 genAmount; // amount distributed to gen + uint256 potAmount; // amount added to pot + } + struct Player { + address addr; // player address + bytes32 name; // player name + uint256 win; // winnings vault + uint256 gen; // general vault + uint256 aff; // affiliate vault + uint256 lrnd; // last round played + uint256 laff; // last affiliate id used + } + struct PlayerRounds { + uint256 eth; // eth player has added to round (used for eth limiter) + uint256 keys; // keys + uint256 mask; // player mask + uint256 ico; // ICO phase investment + } + struct Round { + uint256 plyr; // pID of player in lead， lead领导吗？ + uint256 team; // tID of team in lead + uint256 end; // time ends/ended + bool ended; // has round end function been ran 这个开关值得研究下 + uint256 strt; // time round started + uint256 keys; // keys + uint256 eth; // total eth in + uint256 pot; // eth to pot (during round) / final amount paid to winner (after round ends) + uint256 mask; // global mask + uint256 ico; // total eth sent in during ICO phase + uint256 icoGen; // total eth for gen during ICO phase + uint256 icoAvg; // average key price for ICO phase + } + struct TeamFee { + uint256 gen; // % of buy in thats paid to key holders of current round + uint256 p3d; // % of buy in thats paid to p3d holders + } + struct PotSplit { + uint256 gen; // % of pot thats paid to key holders of current round + uint256 p3d; // % of pot thats paid to p3d holders + } +} + +// File: contracts\F3Devents.sol + +contract F3Devents { + // fired whenever a player registers a name + event OnNewName + ( + uint256 indexed playerID, + address indexed playerAddress, + bytes32 indexed playerName, + bool isNewPlayer, + uint256 affiliateID, + address affiliateAddress, + bytes32 affiliateName, + uint256 amountPaid, + uint256 timeStamp + ); + + // fired at end of buy or reload + event OnEndTx + ( + uint256 compressedData, + uint256 compressedIDs, + bytes32 playerName, + address playerAddress, + uint256 ethIn, + uint256 keysBought, + address winnerAddr, + bytes32 winnerName, + uint256 amountWon, + uint256 newPot, + uint256 P3DAmount, + uint256 genAmount, + uint256 potAmount, + uint256 airDropPot + ); + + // fired whenever theres a withdraw + event OnWithdraw + ( + uint256 indexed playerID, + address playerAddress, + bytes32 playerName, + uint256 ethOut, + uint256 timeStamp + ); + + // fired whenever a withdraw forces end round to be ran + event OnWithdrawAndDistribute + ( + address playerAddress, + bytes32 playerName, + uint256 ethOut, + uint256 compressedData, + uint256 compressedIDs, + address winnerAddr, + bytes32 winnerName, + uint256 amountWon, + uint256 newPot, + uint256 P3DAmount, + uint256 genAmount + ); + + // (fomo3d long only) fired whenever a player tries a buy after round timer + // hit zero, and causes end round to be ran. + event OnBuyAndDistribute + ( + address playerAddress, + bytes32 playerName, + uint256 ethIn, + uint256 compressedData, + uint256 compressedIDs, + address winnerAddr, + bytes32 winnerName, + uint256 amountWon, + uint256 newPot, + uint256 P3DAmount, + uint256 genAmount + ); + + // (fomo3d long only) fired whenever a player tries a reload after round timer + // hit zero, and causes end round to be ran. + event OnReLoadAndDistribute + ( + address playerAddress, + bytes32 playerName, + uint256 compressedData, + uint256 compressedIDs, + address winnerAddr, + bytes32 winnerName, + uint256 amountWon, + uint256 newPot, + uint256 P3DAmount, + uint256 genAmount + ); + + // fired whenever an affiliate is paid + event OnAffiliatePayout + ( + uint256 indexed affiliateID, + address affiliateAddress, + bytes32 affiliateName, + uint256 indexed roundID, + uint256 indexed buyerID, + uint256 amount, + uint256 timeStamp + ); + + // received pot swap deposit + event OnPotSwapDeposit + ( + uint256 roundID, + uint256 amountAddedToPot + ); +} + +// File: contracts\modularLong.sol + +contract Modularlong is F3Devents {} + +// File: contracts\FoMo3Dlong.sol + +contract FoMo3Dlong is Modularlong { + using SafeMath for *; + using NameFilter for string; + using F3DKeysCalcLong for uint256; + + + //TODO: + //JIincForwarderInterface constant private Jekyll_Island_Inc = JIincForwarderInterface(0x508D1c04cd185E693d22125f3Cc6DC81F7Ce9477); + PlayerBookInterface constant private PlayerBook = PlayerBookInterface(0x19dB4339c0ad1BE41FE497795FF2c5263962a573); + + address public constant TEAMWALLET = 0xE9675cdAf47bab3Eef5B1f1c2b7f8d41cDcf9b29; + address[] public leaderWallets; +//============================================================================== +// _ _ _ |`. _ _ _ |_ | _ _ . +// (_(_)| |~|~|(_||_|| (_||_)|(/__\ . (game settings) +//=================_|=========================================================== + string constant public name = "Peach Will"; + string constant public symbol = "PW"; + uint256 private constant RNDEXTRA_ = 1 hours; //24 hours; // length of the very first ICO + uint256 private constant RNDGAP_ = 15 seconds; // length of ICO phase, set to 1 year for EOS. + uint256 constant private RNDINIT_ = 10 hours; //1 hours; // round timer starts at this + uint256 constant private RNDINC_ = 88 seconds; // every full key purchased adds this much to the timer + uint256 constant private RNDMAX_ = 10 hours; // 24 hours; // max length a round timer can be +//============================================================================== +// _| _ _|_ _ _ _ _|_ _ . +// (_|(_| | (_| _\(/_ | |_||_) . (data used to store game info that changes) +//=============================|================================================ + uint256 public airDropPot_; // person who gets the airdrop wins part of this pot + uint256 public airDropTracker_ = 0; // incremented each time a "qualified" tx occurs. used to determine winning air drop + uint256 public rID_; // round id number / total rounds that have happened +//**************** +// PLAYER DATA +//**************** + mapping (address => uint256) public pIDxAddr_; // (addr => pID) returns player id by address + mapping (bytes32 => uint256) public pIDxName_; // (name => pID) returns player id by name + mapping (uint256 => F3Ddatasets.Player) public plyr_; // (pID => data) player data + mapping (uint256 => mapping (uint256 => F3Ddatasets.PlayerRounds)) public plyrRnds_; // (pID => rID => data) player round data by player id & round id + mapping (uint256 => mapping (bytes32 => bool)) public plyrNames_; // (pID => name => bool) list of names a player owns. (used so you can change your display name amongst any name you own) +//**************** +// ROUND DATA +//**************** + mapping (uint256 => F3Ddatasets.Round) public round_; // (rID => data) round data + mapping (uint256 => mapping(uint256 => uint256)) public rndTmEth_; // (rID => tID => data) eth in per team, by round id and team id +//**************** +// TEAM FEE DATA , Team的费用分配数据 +//**************** + mapping (uint256 => F3Ddatasets.TeamFee) public fees_; // (team => fees) fee distribution by team + mapping (uint256 => F3Ddatasets.PotSplit) public potSplit_; // (team => fees) pot split distribution by team +//============================================================================== +// _ _ _ __|_ _ __|_ _ _ . +// (_(_)| |_\ | | |_|(_ | (_)| . (initial data setup upon contract deploy) +//============================================================================== + constructor() + public + { + // Team allocation structures + // 0 = whales + // 1 = bears + // 2 = sneks + // 3 = bulls + + // Team allocation percentages + // (F3D, P3D) + (Pot , Referrals, Community) + // Referrals / Community rewards are mathematically designed to come from the winner's share of the pot. + fees_[0] = F3Ddatasets.TeamFee(54,0); //20% to pot, 10% to aff, 10% to com, 5% to leader swap, 1% to air drop pot + fees_[1] = F3Ddatasets.TeamFee(41,0); //33% to pot, 10% to aff, 10% to com, 5% to leader swap, 1% to air drop pot + fees_[2] = F3Ddatasets.TeamFee(30,0); //44% to pot, 10% to aff, 10% to com, 5% to leader swap, 1% to air drop pot + fees_[3] = F3Ddatasets.TeamFee(40,0); //34% to pot, 10% to aff, 10% to com, 5% to leader swap, 1% to air drop pot + + // how to split up the final pot based on which team was picked + // (F3D, P3D) + potSplit_[0] = F3Ddatasets.PotSplit(37,0); //48% to winner, 10% to next round, 5% to com + potSplit_[1] = F3Ddatasets.PotSplit(34,0); //48% to winner, 13% to next round, 5% to com + potSplit_[2] = F3Ddatasets.PotSplit(25,0); //48% to winner, 22% to next round, 5% to com + potSplit_[3] = F3Ddatasets.PotSplit(32,0); //48% to winner, 15% to next round, 5% to com + + leaderWallets.length = 4; + leaderWallets[0]= 0x326d8d593195a3153f6d55d7791c10af9bcef597; + leaderWallets[1]= 0x15B474F7DE7157FA0dB9FaaA8b82761E78E804B9; + leaderWallets[2]= 0x0c2d482FBc1da4DaCf3CD05b6A5955De1A296fa8; + leaderWallets[3]= 0xD3d96E74aFAE57B5191DC44Bdb08b037355523Ba; + + } +//============================================================================== +// _ _ _ _|. |`. _ _ _ . +// | | |(_)(_||~|~|(/_| _\ . (these are safety checks) +//============================================================================== + /** + * @dev used to make sure no one can interact with contract until it has + * been activated. + */ + modifier isActivated() { + require(activated_ == true, "its not ready yet. check ?eta in discord"); + _; + } + + /** + * @dev prevents contracts from interacting with fomo3d + */ + modifier isHuman() { + address _Addr = msg.sender; + require (_Addr == tx.origin); + + uint256 _codeLength; + + assembly {_codeLength := extcodesize(_Addr)} + require(_codeLength == 0, "sorry humans only"); + _; + } + + /** + * @dev sets boundaries for incoming tx + */ + modifier isWithinLimits(uint256 _eth) { + require(_eth >= 1000000000, "pocket lint: not a valid currency"); + require(_eth <= 100000000000000000000000, "no vitalik, no"); + _; + } + + /** + * + */ + modifier onlyDevs() { + //TODO: + require( + msg.sender == 0xE9675cdAf47bab3Eef5B1f1c2b7f8d41cDcf9b29 || + msg.sender == 0x0020116131498D968DeBCF75E5A11F77e7e1CadE, + "only team just can activate" + ); + _; + } + +//============================================================================== +// _ |_ |. _ |` _ __|_. _ _ _ . +// |_)|_||_)||(_ ~|~|_|| |(_ | |(_)| |_\ . (use these to interact with contract) +//====|========================================================================= + /** + * @dev emergency buy uses last stored affiliate ID and team snek + */ + function() + isActivated() + isHuman() + isWithinLimits(msg.value) + external + payable + { + // set up our tx event data and determine if player is new or not + F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_); + + // fetch player id + uint256 _PID = pIDxAddr_[msg.sender]; + + // buy core + buyCore(_PID, plyr_[_PID].laff, 2, _eventData_); + } + + /** + * @dev converts all incoming ethereum to keys. + * -functionhash- 0x8f38f309 (using ID for affiliate) + * -functionhash- 0x98a0871d (using address for affiliate) + * -functionhash- 0xa65b37a1 (using name for affiliate) + * _affCode the ID/address/name of the player who gets the affiliate fee + * _Team what team is the player playing for? + */ + function buyXid(uint256 _AffCode, uint256 _Team) + isActivated() + isHuman() + isWithinLimits(msg.value) + public + payable + { + // set up our tx event data and determine if player is new or not + F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_); + + // fetch player id + uint256 _PID = pIDxAddr_[msg.sender]; + + // manage affiliate residuals + // if no affiliate code was given or player tried to use their own, lolz + if (_AffCode == 0 || _AffCode == _PID) + { + // use last stored affiliate code + _AffCode = plyr_[_PID].laff; + + // if affiliate code was given & its not the same as previously stored + } else if (_AffCode != plyr_[_PID].laff) { + // update last affiliate + plyr_[_PID].laff = _AffCode; + } + + // verify a valid team was selected + _Team = verifyTeam(_Team); + + // buy core + buyCore(_PID, _AffCode, _Team, _eventData_); + } + + function buyXaddr(address _AffCode, uint256 _Team) + isActivated() + isHuman() + isWithinLimits(msg.value) + public + payable + { + // set up our tx event data and determine if player is new or not + F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_); + + // fetch player id + uint256 _PID = pIDxAddr_[msg.sender]; + + // manage affiliate residuals + uint256 _AffID; + // if no affiliate code was given or player tried to use their own, lolz + if (_AffCode == address(0) || _AffCode == msg.sender) + { + // use last stored affiliate code + _AffID = plyr_[_PID].laff; + + // if affiliate code was given + } else { + // get affiliate ID from aff Code + _AffID = pIDxAddr_[_AffCode]; + + // if affID is not the same as previously stored + if (_AffID != plyr_[_PID].laff) + { + // update last affiliate + plyr_[_PID].laff = _AffID; + } + } + + // verify a valid team was selected + _Team = verifyTeam(_Team); + + // buy core + buyCore(_PID, _AffID, _Team, _eventData_); + } + + function buyXname(bytes32 _AffCode, uint256 _Team) + isActivated() + isHuman() + isWithinLimits(msg.value) + public + payable + { + // set up our tx event data and determine if player is new or not + F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_); + + // fetch player id + uint256 _PID = pIDxAddr_[msg.sender]; + + // manage affiliate residuals + uint256 _AffID; + // if no affiliate code was given or player tried to use their own, lolz + if (_AffCode == '' || _AffCode == plyr_[_PID].name) + { + // use last stored affiliate code + _AffID = plyr_[_PID].laff; + + // if affiliate code was given + } else { + // get affiliate ID from aff Code + _AffID = pIDxName_[_AffCode]; + + // if affID is not the same as previously stored + if (_AffID != plyr_[_PID].laff) + { + // update last affiliate + plyr_[_PID].laff = _AffID; + } + } + + // verify a valid team was selected + _Team = verifyTeam(_Team); + + // buy core + buyCore(_PID, _AffID, _Team, _eventData_); + } + + /** + * @dev essentially the same as buy, but instead of you sending ether + * from your wallet, it uses your unwithdrawn earnings. + * -functionhash- 0x349cdcac (using ID for affiliate) + * -functionhash- 0x82bfc739 (using address for affiliate) + * -functionhash- 0x079ce327 (using name for affiliate) + * _affCode the ID/address/name of the player who gets the affiliate fee + * _Team what team is the player playing for? + * _eth amount of earnings to use (remainder returned to gen vault) + */ + function reLoadXid(uint256 _AffCode, uint256 _Team, uint256 _Eth) + isActivated() + isHuman() + isWithinLimits(_Eth) + public + { + // set up our tx event data + F3Ddatasets.EventReturns memory _eventData_; + + // fetch player ID + uint256 _PID = pIDxAddr_[msg.sender]; + + // manage affiliate residuals + // if no affiliate code was given or player tried to use their own, lolz + if (_AffCode == 0 || _AffCode == _PID) + { + // use last stored affiliate code + _AffCode = plyr_[_PID].laff; + + // if affiliate code was given & its not the same as previously stored + } else if (_AffCode != plyr_[_PID].laff) { + // update last affiliate + plyr_[_PID].laff = _AffCode; + } + + // verify a valid team was selected + _Team = verifyTeam(_Team); + + // reload core + reLoadCore(_PID, _AffCode, _Team, _Eth, _eventData_); + } + + function reLoadXaddr(address _AffCode, uint256 _Team, uint256 _Eth) + isActivated() + isHuman() + isWithinLimits(_Eth) + public + { + // set up our tx event data + F3Ddatasets.EventReturns memory _eventData_; + + // fetch player ID + uint256 _PID = pIDxAddr_[msg.sender]; + + // manage affiliate residuals + uint256 _AffID; + // if no affiliate code was given or player tried to use their own, lolz + if (_AffCode == address(0) || _AffCode == msg.sender) + { + // use last stored affiliate code + _AffID = plyr_[_PID].laff; + + // if affiliate code was given + } else { + // get affiliate ID from aff Code + _AffID = pIDxAddr_[_AffCode]; + + // if affID is not the same as previously stored + if (_AffID != plyr_[_PID].laff) + { + // update last affiliate + plyr_[_PID].laff = _AffID; + } + } + + // verify a valid team was selected + _Team = verifyTeam(_Team); + + // reload core + reLoadCore(_PID, _AffID, _Team, _Eth, _eventData_); + } + + function reLoadXname(bytes32 _AffCode, uint256 _Team, uint256 _Eth) + isActivated() + isHuman() + isWithinLimits(_Eth) + public + { + // set up our tx event data + F3Ddatasets.EventReturns memory _eventData_; + + // fetch player ID + uint256 _PID = pIDxAddr_[msg.sender]; + + // manage affiliate residuals + uint256 _AffID; + // if no affiliate code was given or player tried to use their own, lolz + if (_AffCode == '' || _AffCode == plyr_[_PID].name) + { + // use last stored affiliate code + _AffID = plyr_[_PID].laff; + + // if affiliate code was given + } else { + // get affiliate ID from aff Code + _AffID = pIDxName_[_AffCode]; + + // if affID is not the same as previously stored + if (_AffID != plyr_[_PID].laff) + { + // update last affiliate + plyr_[_PID].laff = _AffID; + } + } + + // verify a valid team was selected + _Team = verifyTeam(_Team); + + // reload core + reLoadCore(_PID, _AffID, _Team, _Eth, _eventData_); + } + + /** + * @dev withdraws all of your earnings. + * -functionhash- 0x3ccfd60b + */ + function withdraw() + isActivated() + isHuman() + external + { + // setup local rID + uint256 _RID = rID_; + + // grab time + uint256 _now = now; + + // fetch player ID + uint256 _PID = pIDxAddr_[msg.sender]; + + // setup temp var for player eth + uint256 _eth; + + // check to see if round has ended and no one has run round end yet + if (_now > round_[_RID].end && round_[_RID].ended == false && round_[_RID].plyr != 0) + { + // set up our tx event data + F3Ddatasets.EventReturns memory _eventData_; + + // end the round (distributes pot) + round_[_RID].ended = true; + _eventData_ = endRound(_eventData_); + + // get their earnings + _eth = withdrawEarnings(_PID); + + // gib moni + if (_eth > 0) + plyr_[_PID].addr.transfer(_eth); + + // build event data + _eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000); + _eventData_.compressedIDs = _eventData_.compressedIDs + _PID; + + // fire withdraw and distribute event + emit F3Devents.OnWithdrawAndDistribute + ( + msg.sender, + plyr_[_PID].name, + _eth, + _eventData_.compressedData, + _eventData_.compressedIDs, + _eventData_.winnerAddr, + _eventData_.winnerName, + _eventData_.amountWon, + _eventData_.newPot, + _eventData_.P3DAmount, + _eventData_.genAmount + ); + + // in any other situation + } else { + // get their earnings + _eth = withdrawEarnings(_PID); + + // gib moni + if (_eth > 0) + plyr_[_PID].addr.transfer(_eth); + + // fire withdraw event + emit F3Devents.OnWithdraw(_PID, msg.sender, plyr_[_PID].name, _eth, _now); + } + } + + /** + * @dev use these to register names. they are just wrappers that will send the + * registration requests to the PlayerBook contract. So registering here is the + * same as registering there. UI will always display the last name you registered. + * but you will still own all previously registered names to use as affiliate + * links. + * - must pay a registration fee. + * - name must be unique + * - names will be converted to lowercase + * - name cannot start or end with a space + * - cannot have more than 1 space in a row + * - cannot be only numbers + * - cannot start with 0x + * - name must be at least 1 char + * - max length of 32 characters long + * - allowed characters: a-z, 0-9, and space + * -functionhash- 0x921dec21 (using ID for affiliate) + * -functionhash- 0x3ddd4698 (using address for affiliate) + * -functionhash- 0x685ffd83 (using name for affiliate) + * _NameString players desired name + * _affCode affiliate ID, address, or name of who referred you + * _all set to true if you want this to push your info to all games + * (this might cost a lot of gas) + */ + function registerNameXID(string _NameString, uint256 _AffCode, bool _All) + isHuman() + external + payable + { + bytes32 _Name = _NameString.nameFilter(); + address _Addr = msg.sender; + uint256 _paid = msg.value; + (bool _isNewPlayer, uint256 _AffID) = PlayerBook.registerNameXIDFromDapp.value(_paid)(_Addr, _Name, _AffCode, _All); + + uint256 _PID = pIDxAddr_[_Addr]; + + // fire event + emit F3Devents.OnNewName(_PID, _Addr, _Name, _isNewPlayer, _AffID, plyr_[_AffID].addr, plyr_[_AffID].name, _paid, now); + } + + function registerNameXaddr(string _NameString, address _AffCode, bool _All) + isHuman() + external + payable + { + bytes32 _Name = _NameString.nameFilter(); + address _Addr = msg.sender; + uint256 _paid = msg.value; + (bool _isNewPlayer, uint256 _AffID) = PlayerBook.registerNameXaddrFromDapp.value(msg.value)(msg.sender, _Name, _AffCode, _All); + + uint256 _PID = pIDxAddr_[_Addr]; + + // fire event + emit F3Devents.OnNewName(_PID, _Addr, _Name, _isNewPlayer, _AffID, plyr_[_AffID].addr, plyr_[_AffID].name, _paid, now); + } + + function registerNameXname(string _NameString, bytes32 _AffCode, bool _All) + isHuman() + external + payable + { + bytes32 _Name = _NameString.nameFilter(); + address _Addr = msg.sender; + uint256 _paid = msg.value; + (bool _isNewPlayer, uint256 _AffID) = PlayerBook.registerNameXnameFromDapp.value(msg.value)(msg.sender, _Name, _AffCode, _All); + + uint256 _PID = pIDxAddr_[_Addr]; + + // fire event + emit F3Devents.OnNewName(_PID, _Addr, _Name, _isNewPlayer, _AffID, plyr_[_AffID].addr, plyr_[_AffID].name, _paid, now); + } +//============================================================================== +// _ _ _|__|_ _ _ _ . +// (_|(/_ | | (/_| _\ . (for UI & viewing things on etherscan) +//=====_|======================================================================= + /** + * @dev return the price buyer will pay for next 1 individual key. + * -functionhash- 0x018a25e8 + * @return price for next key bought (in wei format) + */ + function getBuyPrice() + external + view + returns(uint256) + { + // setup local rID + uint256 _RID = rID_; + + // grab time + uint256 _now = now; + + // are we in a round? + if (_now > round_[_RID].strt + RNDGAP_ && (_now <= round_[_RID].end || (_now > round_[_RID].end && round_[_RID].plyr == 0))) + return ( (round_[_RID].keys.add(1000000000000000000)).ethRec(1000000000000000000) ); + else // rounds over. need price for new round + return ( 75000000000000 ); // init + } + + /** + * @dev returns time left. dont spam this, you'll ddos yourself from your node + * provider + * -functionhash- 0xc7e284b8 + * @return time left in seconds + */ + function getTimeLeft() + external + view + returns(uint256) + { + // setup local rID + uint256 _RID = rID_; + + // grab time + uint256 _now = now; + + if (_now < round_[_RID].end) + if (_now > round_[_RID].strt + RNDGAP_) + return( (round_[_RID].end).sub(_now) ); + else + return( (round_[_RID].strt + RNDGAP_).sub(_now) ); + else + return(0); + } + + /** + * @dev returns player earnings per vaults + * -functionhash- 0x63066434 + * @return winnings vault + * @return general vault + * @return affiliate vault + */ + function getPlayerVaults(uint256 _PID) + external + view + returns(uint256 ,uint256, uint256) + { + // setup local rID + uint256 _RID = rID_; + + // if round has ended. but round end has not been run (so contract has not distributed winnings) + if (now > round_[_RID].end && round_[_RID].ended == false && round_[_RID].plyr != 0) + { + // if player is winner + if (round_[_RID].plyr == _PID) + { + return + ( + (plyr_[_PID].win).add( ((round_[_RID].pot).mul(48)) / 100 ), + (plyr_[_PID].gen).add( getPlayerVaultsHelper(_PID, _RID).sub(plyrRnds_[_PID][_RID].mask) ), + plyr_[_PID].aff + ); + // if player is not the winner + } else { + return + ( + plyr_[_PID].win, + (plyr_[_PID].gen).add( getPlayerVaultsHelper(_PID, _RID).sub(plyrRnds_[_PID][_RID].mask) ), + plyr_[_PID].aff + ); + } + + // if round is still going on, or round has ended and round end has been ran + } else { + return + ( + plyr_[_PID].win, + (plyr_[_PID].gen).add(calcUnMaskedEarnings(_PID, plyr_[_PID].lrnd)), + plyr_[_PID].aff + ); + } + } + + /** + * solidity hates stack limits. this lets us avoid that hate + */ + function getPlayerVaultsHelper(uint256 _PID, uint256 _RID) + private + view + returns(uint256) + { + return( ((((round_[_RID].mask).add(((((round_[_RID].pot).mul(potSplit_[round_[_RID].team].gen)) / 100).mul(1000000000000000000)) / (round_[_RID].keys))).mul(plyrRnds_[_PID][_RID].keys)) / 1000000000000000000) ); + } + + /** + * @dev returns all current round info needed for front end + * -functionhash- 0x747dff42 + * @return eth invested during ICO phase + * @return round id + * @return total keys for round + * @return time round ends + * @return time round started + * @return current pot + * @return current team ID & player ID in lead + * @return current player in leads address + * @return current player in leads name + * @return whales eth in for round + * @return bears eth in for round + * @return sneks eth in for round + * @return bulls eth in for round + * @return airdrop tracker # & airdrop pot + */ + function getCurrentRoundInfo() + external + view + returns(uint256, uint256, uint256, uint256, uint256, uint256, uint256, address, bytes32, uint256, uint256, uint256, uint256, uint256) + { + // setup local rID + uint256 _RID = rID_; + + return + ( + round_[_RID].ico, //0 + _RID, //1 + round_[_RID].keys, //2 + round_[_RID].end, //3 + round_[_RID].strt, //4 + round_[_RID].pot, //5 + (round_[_RID].team + (round_[_RID].plyr * 10)), //6 + plyr_[round_[_RID].plyr].addr, //7 + plyr_[round_[_RID].plyr].name, //8 + rndTmEth_[_RID][0], //9 + rndTmEth_[_RID][1], //10 + rndTmEth_[_RID][2], //11 + rndTmEth_[_RID][3], //12 + airDropTracker_ + (airDropPot_ * 1000) //13 + ); + } + + /** + * @dev returns player info based on address. if no address is given, it will + * use msg.sender + * -functionhash- 0xee0b5d8b + * _Addr address of the player you want to lookup + * @return player ID + * @return player name + * @return keys owned (current round) + * @return winnings vault + * @return general vault + * @return affiliate vault + * @return player round eth + */ + function getPlayerInfoByAddress(address _Addr) + external + view + returns(uint256, bytes32, uint256, uint256, uint256, uint256, uint256) + { + // setup local rID + uint256 _RID = rID_; + + if (_Addr == address(0)) + { + _Addr == msg.sender; + } + uint256 _PID = pIDxAddr_[_Addr]; + + return + ( + _PID, //0 + plyr_[_PID].name, //1 + plyrRnds_[_PID][_RID].keys, //2 + plyr_[_PID].win, //3 + (plyr_[_PID].gen).add(calcUnMaskedEarnings(_PID, plyr_[_PID].lrnd)), //4 + plyr_[_PID].aff, //5 + plyrRnds_[_PID][_RID].eth //6 + ); + } + +//============================================================================== +// _ _ _ _ | _ _ . _ . +// (_(_)| (/_ |(_)(_||(_ . (this + tools + calcs + modules = our softwares engine) +//=====================_|======================================================= + /** + * @dev logic runs whenever a buy order is executed. determines how to handle + * incoming eth depending on if we are in an active round or not + */ + function buyCore(uint256 _PID, uint256 _AffID, uint256 _Team, F3Ddatasets.EventReturns memory _EventData_) + private + { + // setup local rID + uint256 _RID = rID_; + + // grab time + uint256 _now = now; + + // if round is active + if (_now > round_[_RID].strt + RNDGAP_ && (_now <= round_[_RID].end || (_now > round_[_RID].end && round_[_RID].plyr == 0))) + { + // call core + core(_RID, _PID, msg.value, _AffID, _Team, _EventData_); + + // if round is not active + } else { + // check to see if end round needs to be ran + if (_now > round_[_RID].end && round_[_RID].ended == false) + { + // end the round (distributes pot) & start new round + round_[_RID].ended = true; + _EventData_ = endRound(_EventData_); + + // build event data + _EventData_.compressedData = _EventData_.compressedData + (_now * 1000000000000000000); + _EventData_.compressedIDs = _EventData_.compressedIDs + _PID; + + // fire buy and distribute event + emit F3Devents.OnBuyAndDistribute + ( + msg.sender, + plyr_[_PID].name, + msg.value, + _EventData_.compressedData, + _EventData_.compressedIDs, + _EventData_.winnerAddr, + _EventData_.winnerName, + _EventData_.amountWon, + _EventData_.newPot, + _EventData_.P3DAmount, + _EventData_.genAmount + ); + } + + // put eth in players vault + plyr_[_PID].gen = plyr_[_PID].gen.add(msg.value); + } + } + + /** + * @dev logic runs whenever a reload order is executed. determines how to handle + * incoming eth depending on if we are in an active round or not + */ + function reLoadCore(uint256 _PID, uint256 _AffID, uint256 _Team, uint256 _Eth, F3Ddatasets.EventReturns memory _EventData_) + private + { + // setup local rID + uint256 _RID = rID_; + + // grab time + uint256 _now = now; + + // if round is active + if (_now > round_[_RID].strt + RNDGAP_ && (_now <= round_[_RID].end || (_now > round_[_RID].end && round_[_RID].plyr == 0))) + { + // get earnings from all vaults and return unused to gen vault + // because we use a custom safemath library. this will throw if player + // tried to spend more eth than they have. + plyr_[_PID].gen = withdrawEarnings(_PID).sub(_Eth); + + // call core + core(_RID, _PID, _Eth, _AffID, _Team, _EventData_); + + // if round is not active and end round needs to be ran + } else if (_now > round_[_RID].end && round_[_RID].ended == false) { + // end the round (distributes pot) & start new round + round_[_RID].ended = true; + _EventData_ = endRound(_EventData_); + + // build event data + _EventData_.compressedData = _EventData_.compressedData + (_now * 1000000000000000000); + _EventData_.compressedIDs = _EventData_.compressedIDs + _PID; + + // fire buy and distribute event + emit F3Devents.OnReLoadAndDistribute + ( + msg.sender, + plyr_[_PID].name, + _EventData_.compressedData, + _EventData_.compressedIDs, + _EventData_.winnerAddr, + _EventData_.winnerName, + _EventData_.amountWon, + _EventData_.newPot, + _EventData_.P3DAmount, + _EventData_.genAmount + ); + } + } + + /** + * @dev this is the core logic for any buy/reload that happens while a round + * is live. + */ + function core(uint256 _RID, uint256 _PID, uint256 _Eth, uint256 _AffID, uint256 _Team, F3Ddatasets.EventReturns memory _EventData_) + private + { + // if player is new to round + if (plyrRnds_[_PID][_RID].keys == 0) + _EventData_ = managePlayer(_PID, _EventData_); + + // early round eth limiter + if (round_[_RID].eth < 100000000000000000000 && plyrRnds_[_PID][_RID].eth.add(_Eth) > 1000000000000000000) + { + uint256 _availableLimit = (1000000000000000000).sub(plyrRnds_[_PID][_RID].eth); + uint256 _refund = _Eth.sub(_availableLimit); + plyr_[_PID].gen = plyr_[_PID].gen.add(_refund); + _Eth = _availableLimit; + } + + // if eth left is greater than min eth allowed (sorry no pocket lint) + if (_Eth > 1000000000) + { + + // mint the new keys + uint256 _keys = (round_[_RID].eth).keysRec(_Eth); + + // if they bought at least 1 whole key + if (_keys >= 1000000000000000000) + { + updateTimer(_keys, _RID); + + // set new leaders + if (round_[_RID].plyr != _PID) + round_[_RID].plyr = _PID; + if (round_[_RID].team != _Team) + round_[_RID].team = _Team; + + // set the new leader bool to true + _EventData_.compressedData = _EventData_.compressedData + 100; + } + + // manage airdrops + if (_Eth >= 100000000000000000) + { + airDropTracker_++; + if (airdrop() == true) + { + // gib muni + uint256 _prize; + if (_Eth >= 10000000000000000000) + { + // calculate prize and give it to winner + _prize = ((airDropPot_).mul(75)) / 100; + plyr_[_PID].win = (plyr_[_PID].win).add(_prize); + + // adjust airDropPot + airDropPot_ = (airDropPot_).sub(_prize); + + // let event know a tier 3 prize was won + _EventData_.compressedData += 300000000000000000000000000000000; + } else if (_Eth >= 1000000000000000000 && _Eth < 10000000000000000000) { + // calculate prize and give it to winner + _prize = ((airDropPot_).mul(50)) / 100; + plyr_[_PID].win = (plyr_[_PID].win).add(_prize); + + // adjust airDropPot + airDropPot_ = (airDropPot_).sub(_prize); + + // let event know a tier 2 prize was won + _EventData_.compressedData += 200000000000000000000000000000000; + } else if (_Eth >= 100000000000000000 && _Eth < 1000000000000000000) { + // calculate prize and give it to winner + _prize = ((airDropPot_).mul(25)) / 100; + plyr_[_PID].win = (plyr_[_PID].win).add(_prize); + + // adjust airDropPot + airDropPot_ = (airDropPot_).sub(_prize); + + // let event know a tier 3 prize was won + _EventData_.compressedData += 300000000000000000000000000000000; + } + // set airdrop happened bool to true + _EventData_.compressedData += 10000000000000000000000000000000; + // let event know how much was won + _EventData_.compressedData += _prize * 1000000000000000000000000000000000; + + // reset air drop tracker + airDropTracker_ = 0; + } + } + + // store the air drop tracker number (number of buys since last airdrop) + _EventData_.compressedData = _EventData_.compressedData + (airDropTracker_ * 1000); + + // update player + plyrRnds_[_PID][_RID].keys = _keys.add(plyrRnds_[_PID][_RID].keys); + plyrRnds_[_PID][_RID].eth = _Eth.add(plyrRnds_[_PID][_RID].eth); + + // update round + round_[_RID].keys = _keys.add(round_[_RID].keys); + round_[_RID].eth = _Eth.add(round_[_RID].eth); + rndTmEth_[_RID][_Team] = _Eth.add(rndTmEth_[_RID][_Team]); + + // distribute eth + _EventData_ = distributeExternal(_RID, _PID, _Eth, _AffID, _Team, _EventData_); + _EventData_ = distributeInternal(_RID, _PID, _Eth, _Team, _keys, _EventData_); + + // call end tx function to fire end tx event. + endTx(_PID, _Team, _Eth, _keys, _EventData_); + } + } +//============================================================================== +// _ _ | _ | _ _|_ _ _ _ . +// (_(_||(_|_||(_| | (_)| _\ . +//============================================================================== + /** + * @dev calculates unmasked earnings (just calculates, does not update mask) + * @return earnings in wei format + */ + function calcUnMaskedEarnings(uint256 _PID, uint256 _RIDlast) + private + view + returns(uint256) + { + return( (((round_[_RIDlast].mask).mul(plyrRnds_[_PID][_RIDlast].keys)) / (1000000000000000000)).sub(plyrRnds_[_PID][_RIDlast].mask) ); + } + + /** + * @dev returns the amount of keys you would get given an amount of eth. + * -functionhash- 0xce89c80c + * _RID round ID you want price for + * _eth amount of eth sent in + * @return keys received + */ + function calcKeysReceived(uint256 _RID, uint256 _Eth) + external + view + returns(uint256) + { + // grab time + uint256 _now = now; + + // are we in a round? + if (_now > round_[_RID].strt + RNDGAP_ && (_now <= round_[_RID].end || (_now > round_[_RID].end && round_[_RID].plyr == 0))) + return ( (round_[_RID].eth).keysRec(_Eth) ); + else // rounds over. need keys for new round + return ( (_Eth).keys() ); + } + + /** + * @dev returns current eth price for X keys. + * -functionhash- 0xcf808000 + * _keys number of keys desired (in 18 decimal format) + * @return amount of eth needed to send + */ + function iWantXKeys(uint256 _Keys) + external + view + returns(uint256) + { + // setup local rID + uint256 _RID = rID_; + + // grab time + uint256 _now = now; + + // are we in a round? + if (_now > round_[_RID].strt + RNDGAP_ && (_now <= round_[_RID].end || (_now > round_[_RID].end && round_[_RID].plyr == 0))) + return ( (round_[_RID].keys.add(_Keys)).ethRec(_Keys) ); + else // rounds over. need price for new round + return ( (_Keys).eth() ); + } +//============================================================================== +// _|_ _ _ | _ . +// | (_)(_)|_\ . +//============================================================================== + /** + * @dev receives name/player info from names contract + */ + function receivePlayerInfo(uint256 _PID, address _Addr, bytes32 _Name, uint256 _Laff) + external + { + require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm.."); + if (pIDxAddr_[_Addr] != _PID) + pIDxAddr_[_Addr] = _PID; + if (pIDxName_[_Name] != _PID) + pIDxName_[_Name] = _PID; + if (plyr_[_PID].addr != _Addr) + plyr_[_PID].addr = _Addr; + if (plyr_[_PID].name != _Name) + plyr_[_PID].name = _Name; + if (plyr_[_PID].laff != _Laff) + plyr_[_PID].laff = _Laff; + if (plyrNames_[_PID][_Name] == false) + plyrNames_[_PID][_Name] = true; + } + + /** + * @dev receives entire player name list + */ + function receivePlayerNameList(uint256 _PID, bytes32 _Name) + external + { + require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm.."); + if(plyrNames_[_PID][_Name] == false) + plyrNames_[_PID][_Name] = true; + } + + /** + * @dev gets existing or registers new pID. use this when a player may be new + * @return pID + */ + function determinePID(F3Ddatasets.EventReturns memory _EventData_) + private + returns (F3Ddatasets.EventReturns) + { + uint256 _PID = pIDxAddr_[msg.sender]; + // if player is new to this version of fomo3d + if (_PID == 0) + { + // grab their player ID, name and last aff ID, from player names contract + _PID = PlayerBook.getPlayerID(msg.sender); + bytes32 _Name = PlayerBook.getPlayerName(_PID); + uint256 _laff = PlayerBook.getPlayerLAff(_PID); + + // set up player account + pIDxAddr_[msg.sender] = _PID; + plyr_[_PID].addr = msg.sender; + + if (_Name != "") + { + pIDxName_[_Name] = _PID; + plyr_[_PID].name = _Name; + plyrNames_[_PID][_Name] = true; + } + + if (_laff != 0 && _laff != _PID) + plyr_[_PID].laff = _laff; + + // set the new player bool to true + _EventData_.compressedData = _EventData_.compressedData + 1; + } + return (_EventData_); + } + + /** + * @dev checks to make sure user picked a valid team. if not sets team + * to default (sneks) + */ + function verifyTeam(uint256 _Team) + private + pure + returns (uint256) + { + if (_Team < 0 || _Team > 3) + return(2); + else + return(_Team); + } + + /** + * @dev decides if round end needs to be run & new round started. and if + * player unmasked earnings from previously played rounds need to be moved. + */ + function managePlayer(uint256 _PID, F3Ddatasets.EventReturns memory _EventData_) + private + returns (F3Ddatasets.EventReturns) + { + // if player has played a previous round, move their unmasked earnings + // from that round to gen vault. + if (plyr_[_PID].lrnd != 0) + updateGenVault(_PID, plyr_[_PID].lrnd); + + // update player's last round played + plyr_[_PID].lrnd = rID_; + + // set the joined round bool to true + _EventData_.compressedData = _EventData_.compressedData + 10; + + return(_EventData_); + } + + /** + * @dev ends the round. manages paying out winner/splitting up pot + */ + function endRound(F3Ddatasets.EventReturns memory _EventData_) + private + returns (F3Ddatasets.EventReturns) + { + // setup local rID + uint256 _RID = rID_; + + // grab our winning player and team id's + uint256 _winPID = round_[_RID].plyr; + uint256 _winTID = round_[_RID].team; + + // grab our pot amount + uint256 _pot = round_[_RID].pot; + + // calculate our winner share, community rewards, gen share, + // p3d share, and amount reserved for next pot + uint256 _win = (_pot.mul(48)) / 100; + uint256 _com = (_pot / 20); + uint256 _gen = (_pot.mul(potSplit_[_winTID].gen)) / 100; + uint256 _p3d = (_pot.mul(potSplit_[_winTID].p3d)) / 100; + uint256 _res = (((_pot.sub(_win)).sub(_com)).sub(_gen)).sub(_p3d); + + // calculate ppt for round mask + uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_RID].keys); + uint256 _dust = _gen.sub((_ppt.mul(round_[_RID].keys)) / 1000000000000000000); + if (_dust > 0) + { + _gen = _gen.sub(_dust); + _res = _res.add(_dust); + } + + // pay our winner + plyr_[_winPID].win = _win.add(plyr_[_winPID].win); + + // community rewards + + TEAMWALLET.transfer(_com); + + // if (!address(Jekyll_Island_Inc).call.value(_com)(bytes4(keccak256("deposit()")))) + // { + // // This ensures Team Just cannot influence the outcome of FoMo3D with + // // bank migrations by breaking outgoing transactions. + // // Something we would never do. But that's not the point. + // // We spent 2000$ in eth re-deploying just to patch this, we hold the + // // highest belief that everything we create should be trustless. + // // Team JUST, The name you shouldn't have to trust. + // _p3d = _p3d.add(_com); + // _com = 0; + // } + + // distribute gen portion to key holders + round_[_RID].mask = _ppt.add(round_[_RID].mask); + + // send share for p3d to divies + // if (_p3d > 0) + // Divies.deposit.value(_p3d)(); + + // prepare event data + _EventData_.compressedData = _EventData_.compressedData + (round_[_RID].end * 1000000); + _EventData_.compressedIDs = _EventData_.compressedIDs + (_winPID * 100000000000000000000000000) + (_winTID * 100000000000000000); + _EventData_.winnerAddr = plyr_[_winPID].addr; + _EventData_.winnerName = plyr_[_winPID].name; + _EventData_.amountWon = _win; + _EventData_.genAmount = _gen; + _EventData_.P3DAmount = _p3d; + _EventData_.newPot = _res; + + // start next round + rID_++; + _RID++; + round_[_RID].strt = now; + round_[_RID].end = now.add(RNDINIT_).add(RNDGAP_); + round_[_RID].pot = _res; + + return(_EventData_); + } + + /** + * @dev moves any unmasked earnings to gen vault. updates earnings mask + */ + function updateGenVault(uint256 _PID, uint256 _RIDlast) + private + { + uint256 _earnings = calcUnMaskedEarnings(_PID, _RIDlast); + if (_earnings > 0) + { + // put in gen vault + plyr_[_PID].gen = _earnings.add(plyr_[_PID].gen); + // zero out their earnings by updating mask + plyrRnds_[_PID][_RIDlast].mask = _earnings.add(plyrRnds_[_PID][_RIDlast].mask); + } + } + + /** + * @dev updates round timer based on number of whole keys bought. + */ + function updateTimer(uint256 _Keys, uint256 _RID) + private + { + // grab time + uint256 _now = now; + + // calculate time based on number of keys bought + uint256 _newTime; + if (_now > round_[_RID].end && round_[_RID].plyr == 0) + _newTime = (((_Keys) / (1000000000000000000)).mul(RNDINC_)).add(_now); + else + _newTime = (((_Keys) / (1000000000000000000)).mul(RNDINC_)).add(round_[_RID].end); + + // compare to max and set new end time + if (_newTime < (RNDMAX_).add(_now)) + round_[_RID].end = _newTime; + else + round_[_RID].end = RNDMAX_.add(_now); + } + + /** + * @dev generates a random number between 0-99 and checks to see if thats + * resulted in an airdrop win + * @return do we have a winner? + */ + function airdrop() + private + view + returns(bool) + { + uint256 seed = uint256(keccak256(abi.encodePacked( + + (block.timestamp).add + (block.difficulty).add + ((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add + (block.gaslimit).add + ((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add + (block.number) + + ))); + if((seed - ((seed / 1000) * 1000)) < airDropTracker_) + return(true); + else + return(false); + } + + /** + * @dev distributes eth based on fees to com, aff, and p3d + */ + function distributeExternal(uint256 _RID, uint256 _PID, uint256 _Eth, uint256 _AffID, uint256 _Team, F3Ddatasets.EventReturns memory _EventData_) + private + returns(F3Ddatasets.EventReturns) + { + // pay 10% out to community rewards + uint256 _com = _Eth / 10; + //uint256 _p3d; + + TEAMWALLET.transfer(_com); + // if (!address(Jekyll_Island_Inc).call.value(_com)(bytes4(keccak256("deposit()")))) + // { + // // This ensures Team Just cannot influence the outcome of FoMo3D with + // // bank migrations by breaking outgoing transactions. + // // Something we would never do. But that's not the point. + // // We spent 2000$ in eth re-deploying just to patch this, we hold the + // // highest belief that everything we create should be trustless. + // // Team JUST, The name you shouldn't have to trust. + // _p3d = _com; + // _com = 0; + // } + + // pay 1% out to FoMo3D short + uint256 _leader = _Eth / 20; + //otherF3D_.potSwap.value(_long)(); + + // distribute share to affiliate + uint256 _aff = _Eth / 10; + + // decide what to do with affiliate share of fees + // affiliate must not be self, and must have a name registered + if (_AffID != _PID && plyr_[_AffID].name != '') { + plyr_[_AffID].aff = _aff.add(plyr_[_AffID].aff); + emit F3Devents.OnAffiliatePayout(_AffID, plyr_[_AffID].addr, plyr_[_AffID].name, _RID, _PID, _aff, now); + } else { + _leader =_leader.add(_aff); + } + + leaderWallets[_Team].transfer(_leader); + + // pay out p3d + // _p3d = _p3d.add((_eth.mul(fees_[_Team].p3d)) / (100)); + // if (_p3d > 0) + // { + // // deposit to divies contract + // Divies.deposit.value(_p3d)(); + + // // set up event data + // _eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount); + // } + + return(_EventData_); + } + + function potSwap() + external + payable + { + // setup local rID + uint256 _RID = rID_ + 1; + + round_[_RID].pot = round_[_RID].pot.add(msg.value); + emit F3Devents.OnPotSwapDeposit(_RID, msg.value); + } + + /** + * @dev distributes eth based on fees to gen and pot + */ + function distributeInternal(uint256 _RID, uint256 _PID, uint256 _Eth, uint256 _Team, uint256 _Keys, F3Ddatasets.EventReturns memory _EventData_) + private + returns(F3Ddatasets.EventReturns) + { + // calculate gen share + uint256 _gen = (_Eth.mul(fees_[_Team].gen)) / 100; + + // toss 1% into airdrop pot + uint256 _air = (_Eth / 100); + airDropPot_ = airDropPot_.add(_air); + + // update eth balance (eth = eth - (com share + pot swap share + aff share + p3d share + airdrop pot share)) + _Eth = _Eth.sub(((_Eth.mul(26)) / 100).add((_Eth.mul(fees_[_Team].p3d)) / 100)); + + // calculate pot + uint256 _pot = _Eth.sub(_gen); + + // distribute gen share (thats what updateMasks() does) and adjust + // balances for dust. + uint256 _dust = updateMasks(_RID, _PID, _gen, _Keys); + if (_dust > 0) + _gen = _gen.sub(_dust); + + // add eth to pot + round_[_RID].pot = _pot.add(_dust).add(round_[_RID].pot); + + // set up event data + _EventData_.genAmount = _gen.add(_EventData_.genAmount); + _EventData_.potAmount = _pot; + + return(_EventData_); + } + + /** + * @dev updates masks for round and player when keys are bought + * @return dust left over + */ + function updateMasks(uint256 _RID, uint256 _PID, uint256 _Gen, uint256 _Keys) + private + returns(uint256) + { + /* MASKING NOTES + earnings masks are a tricky thing for people to wrap their minds around. + the basic thing to understand here. is were going to have a global + tracker based on profit per share for each round, that increases in + relevant proportion to the increase in share supply. + + the player will have an additional mask that basically says "based + on the rounds mask, my shares, and how much i've already withdrawn, + how much is still owed to me?" + */ + + // calc profit per key & round mask based on this buy: (dust goes to pot) + uint256 _ppt = (_Gen.mul(1000000000000000000)) / (round_[_RID].keys); + round_[_RID].mask = _ppt.add(round_[_RID].mask); + + // calculate player earning from their own buy (only based on the keys + // they just bought). & update player earnings mask + uint256 _pearn = (_ppt.mul(_Keys)) / (1000000000000000000); + plyrRnds_[_PID][_RID].mask = (((round_[_RID].mask.mul(_Keys)) / (1000000000000000000)).sub(_pearn)).add(plyrRnds_[_PID][_RID].mask); + + // calculate & return dust + return(_Gen.sub((_ppt.mul(round_[_RID].keys)) / (1000000000000000000))); + } + + /** + * @dev adds up unmasked earnings, & vault earnings, sets them all to 0 + * @return earnings in wei format + */ + function withdrawEarnings(uint256 _PID) + private + returns(uint256) + { + // update gen vault + updateGenVault(_PID, plyr_[_PID].lrnd); + + // from vaults + uint256 _earnings = (plyr_[_PID].win).add(plyr_[_PID].gen).add(plyr_[_PID].aff); + if (_earnings > 0) + { + plyr_[_PID].win = 0; + plyr_[_PID].gen = 0; + plyr_[_PID].aff = 0; + } + + return(_earnings); + } + + /** + * @dev prepares compression data and fires event for buy or reload tx's + */ + function endTx(uint256 _PID, uint256 _Team, uint256 _Eth, uint256 _Keys, F3Ddatasets.EventReturns memory _EventData_) + private + { + _EventData_.compressedData = _EventData_.compressedData + (now * 1000000000000000000) + (_Team * 100000000000000000000000000000); + _EventData_.compressedIDs = _EventData_.compressedIDs + _PID + (rID_ * 10000000000000000000000000000000000000000000000000000); + + emit F3Devents.OnEndTx + ( + _EventData_.compressedData, + _EventData_.compressedIDs, + plyr_[_PID].name, + msg.sender, + _Eth, + _Keys, + _EventData_.winnerAddr, + _EventData_.winnerName, + _EventData_.amountWon, + _EventData_.newPot, + _EventData_.P3DAmount, + _EventData_.genAmount, + _EventData_.potAmount, + airDropPot_ + ); + } +//============================================================================== +// (~ _ _ _._|_ . +// _)(/_(_|_|| | | \/ . +//====================/========================================================= + /** upon contract deploy, it will be deactivated. this is a one time + * use function that will activate the contract. we do this so devs + * have time to set things up on the web end **/ + bool public activated_ = false; + function activate() + onlyDevs() + external + { + // make sure that its been linked. + // can only be ran once + require(activated_ == false, "fomo3d already activated"); + + // activate the contract + activated_ = true; + + // lets start first round + rID_ = 1; + round_[1].strt = now + RNDEXTRA_ - RNDGAP_; + round_[1].end = now + RNDINIT_ + RNDEXTRA_; + } +} diff --git a/utils/slither_format/tests/real_world/0xbf45f4280cfbe7c2d2515a7d984b8c71c15e82b7_EnclavesDEXProxy.sol b/utils/slither_format/tests/real_world/0xbf45f4280cfbe7c2d2515a7d984b8c71c15e82b7_EnclavesDEXProxy.sol new file mode 100644 index 000000000..4afe40fec --- /dev/null +++ b/utils/slither_format/tests/real_world/0xbf45f4280cfbe7c2d2515a7d984b8c71c15e82b7_EnclavesDEXProxy.sol @@ -0,0 +1,286 @@ +pragma solidity ^0.4.18; + +// File: contracts/EtherDeltaI.sol + +contract EtherDeltaI { + + uint public feeMake; //percentage times (1 ether) + uint public feeTake; //percentage times (1 ether) + + mapping (address => mapping (address => uint)) public tokens; //mapping of token addresses to mapping of account balances (token=0 means Ether) + mapping (address => mapping (bytes32 => bool)) public orders; //mapping of user accounts to mapping of order hashes to booleans (true = submitted by user, equivalent to offchain signature) + mapping (address => mapping (bytes32 => uint)) public orderFills; //mapping of user accounts to mapping of order hashes to uints (amount of order that has been filled) + + function deposit() payable; + + function withdraw(uint amount); + + function depositToken(address token, uint amount); + + function withdrawToken(address token, uint amount); + + function balanceOf(address token, address user) constant returns (uint); + + function order(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce); + + function trade(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce, address user, uint8 v, bytes32 r, bytes32 s, uint amount); + + function testTrade(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce, address user, uint8 v, bytes32 r, bytes32 s, uint amount, address sender) constant returns(bool); + + function availableVolume(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce, address user, uint8 v, bytes32 r, bytes32 s) constant returns(uint); + + function amountFilled(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce, address user, uint8 v, bytes32 r, bytes32 s) constant returns(uint); + + function cancelOrder(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce, uint8 v, bytes32 r, bytes32 s); + +} + +// File: contracts/KindMath.sol + +/** + * @title KindMath + * @dev Math operations with safety checks that fail + */ +library KindMath { + function mul(uint256 a, uint256 b) internal pure returns (uint256) { + uint256 c = a * b; + require(a == 0 || c / a == b); + return c; + } + + function div(uint256 a, uint256 b) internal pure returns (uint256) { + // assert(b > 0); // Solidity automatically throws when dividing by 0 + uint256 c = a / b; + // assert(a == b * c + a % b); // There is no case in which this doesn't hold + return c; + } + + function sub(uint256 a, uint256 b) internal pure returns (uint256) { + require(b <= a); + return a - b; + } + + function add(uint256 a, uint256 b) internal pure returns (uint256) { + uint256 c = a + b; + require(c >= a); + return c; + } +} + +// File: contracts/KeyValueStorage.sol + +contract KeyValueStorage { + + mapping(address => mapping(bytes32 => uint256)) _uintStorage; + mapping(address => mapping(bytes32 => address)) _addressStorage; + mapping(address => mapping(bytes32 => bool)) _boolStorage; + mapping(address => mapping(bytes32 => bytes32)) _bytes32Storage; + + /**** Get Methods ***********/ + + function getAddress(bytes32 key) public view returns (address) { + return _addressStorage[msg.sender][key]; + } + + function getUint(bytes32 key) public view returns (uint) { + return _uintStorage[msg.sender][key]; + } + + function getBool(bytes32 key) public view returns (bool) { + return _boolStorage[msg.sender][key]; + } + + function getBytes32(bytes32 key) public view returns (bytes32) { + return _bytes32Storage[msg.sender][key]; + } + + /**** Set Methods ***********/ + + function setAddress(bytes32 key, address value) public { + _addressStorage[msg.sender][key] = value; + } + + function setUint(bytes32 key, uint value) public { + _uintStorage[msg.sender][key] = value; + } + + function setBool(bytes32 key, bool value) public { + _boolStorage[msg.sender][key] = value; + } + + function setBytes32(bytes32 key, bytes32 value) public { + _bytes32Storage[msg.sender][key] = value; + } + + /**** Delete Methods ***********/ + + function deleteAddress(bytes32 key) public { + delete _addressStorage[msg.sender][key]; + } + + function deleteUint(bytes32 key) public { + delete _uintStorage[msg.sender][key]; + } + + function deleteBool(bytes32 key) public { + delete _boolStorage[msg.sender][key]; + } + + function deleteBytes32(bytes32 key) public { + delete _bytes32Storage[msg.sender][key]; + } + +} + +// File: contracts/StorageStateful.sol + +contract StorageStateful { + KeyValueStorage public keyValueStorage; +} + +// File: contracts/StorageConsumer.sol + +contract StorageConsumer is StorageStateful { + function StorageConsumer(address _storageAddress) public { + require(_storageAddress != address(0)); + keyValueStorage = KeyValueStorage(_storageAddress); + } +} + +// File: contracts/TokenI.sol + +contract Token { + /// @return total amount of tokens + function totalSupply() public returns (uint256); + + /// @param _owner The address from which the balance will be retrieved + /// @return The balance + function balanceOf(address _owner) public returns (uint256); + + /// @notice send `_value` token to `_to` from `msg.sender` + /// @param _to The address of the recipient + /// @param _value The amount of token to be transferred + /// @return Whether the transfer was successful or not + function transfer(address _to, uint256 _value) public returns (bool); + + /// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from` + /// @param _from The address of the sender + /// @param _to The address of the recipient + /// @param _value The amount of token to be transferred + /// @return Whether the transfer was successful or not + function transferFrom(address _from, address _to, uint256 _value) public returns (bool); + + /// @notice `msg.sender` approves `_addr` to spend `_value` tokens + /// @param _spender The address of the account able to transfer the tokens + /// @param _value The amount of wei to be approved for transfer + /// @return Whether the approval was successful or not + function approve(address _spender, uint256 _value) public returns (bool); + + /// @param _owner The address of the account owning tokens + /// @param _spender The address of the account able to transfer the tokens + /// @return Amount of remaining tokens allowed to spent + function allowance(address _owner, address _spender) public returns (uint256); + + event Transfer(address indexed _from, address indexed _to, uint256 _value); + event Approval(address indexed _owner, address indexed _spender, uint256 _value); + + uint256 public decimals; + string public name; +} + +// File: contracts/EnclavesDEXProxy.sol + +contract EnclavesDEXProxy is StorageConsumer { + using KindMath for uint256; + + address public admin; //the admin address + address public feeAccount; //the account that will receive fees + + struct EtherDeltaInfo { + uint256 feeMake; + uint256 feeTake; + } + + EtherDeltaInfo public etherDeltaInfo; + + uint256 public feeTake; //percentage times 1 ether + uint256 public feeAmountThreshold; //gasPrice amount under which no fees are charged + + address public etherDelta; + + bool public useEIP712 = true; + bytes32 public tradeABIHash; + bytes32 public withdrawABIHash; + + bool freezeTrading; + bool depositTokenLock; + + mapping (address => mapping (uint256 => bool)) nonceCheck; + + mapping (address => mapping (address => uint256)) public tokens; //mapping of token addresses to mapping of account balances (token=0 means Ether) + mapping (address => mapping (bytes32 => bool)) public orders; //mapping of user accounts to mapping of order hashes to booleans (true = submitted by user, equivalent to offchain signature) + mapping (address => mapping (bytes32 => uint256)) public orderFills; //mapping of user accounts to mapping of order hashes to uints (amount of order that has been filled) + + address internal implementation; + address public proposedImplementation; + uint256 public proposedTimestamp; + + event Upgraded(address _implementation); + event UpgradedProposed(address _proposedImplementation, uint256 _proposedTimestamp); + + modifier onlyAdmin { + require(msg.sender == admin); + _; + } + + function EnclavesDEXProxy(address _storageAddress, address _implementation, address _admin, address _feeAccount, uint256 _feeTake, uint256 _feeAmountThreshold, address _etherDelta, bytes32 _tradeABIHash, bytes32 _withdrawABIHash) public + StorageConsumer(_storageAddress) + { + require(_implementation != address(0)); + implementation = _implementation; + admin = _admin; + feeAccount = _feeAccount; + feeTake = _feeTake; + feeAmountThreshold = _feeAmountThreshold; + etherDelta = _etherDelta; + tradeABIHash = _tradeABIHash; + withdrawABIHash = _withdrawABIHash; + etherDeltaInfo.feeMake = EtherDeltaI(etherDelta).feeMake(); + etherDeltaInfo.feeTake = EtherDeltaI(etherDelta).feeTake(); + } + + function getImplementation() public view returns(address) { + return implementation; + } + + function proposeUpgrade(address _proposedImplementation) public onlyAdmin { + require(implementation != _proposedImplementation); + require(_proposedImplementation != address(0)); + proposedImplementation = _proposedImplementation; + proposedTimestamp = now + 2 weeks; + UpgradedProposed(proposedImplementation, now); + } + + function upgrade() public onlyAdmin { + require(proposedImplementation != address(0)); + require(proposedTimestamp < now); + implementation = proposedImplementation; + Upgraded(implementation); + } + + function () payable public { + bytes memory data = msg.data; + address impl = getImplementation(); + + assembly { + let result := delegatecall(gas, impl, add(data, 0x20), mload(data), 0, 0) + let size := returndatasize + let ptr := mload(0x40) + returndatacopy(ptr, 0, size) + switch result + case 0 { revert(ptr, size) } + default { return(ptr, size) } + } + } + +} \ No newline at end of file diff --git a/utils/slither_format/tests/real_world/0xc6725ae749677f21e4d8f85f41cfb6de49b9db29_BancorConverter.sol b/utils/slither_format/tests/real_world/0xc6725ae749677f21e4d8f85f41cfb6de49b9db29_BancorConverter.sol new file mode 100644 index 000000000..d69f55f04 --- /dev/null +++ b/utils/slither_format/tests/real_world/0xc6725ae749677f21e4d8f85f41cfb6de49b9db29_BancorConverter.sol @@ -0,0 +1,1011 @@ +pragma solidity ^0.4.18; + +/* + Utilities & Common Modifiers +*/ +contract Utils { + /** + constructor + */ + function Utils() public { + } + + // verifies that an amount is greater than zero + modifier greaterThanZero(uint256 _amount) { + require(_amount > 0); + _; + } + + // validates an address - currently only checks that it isn't null + modifier validAddress(address _address) { + require(_address != address(0)); + _; + } + + // verifies that the address is different than this contract address + modifier notThis(address _address) { + require(_address != address(this)); + _; + } + + // Overflow protected math functions + + /** + @dev returns the sum of _x and _y, asserts if the calculation overflows + + @param _x value 1 + @param _y value 2 + + @return sum + */ + function safeAdd(uint256 _x, uint256 _y) internal pure returns (uint256) { + uint256 z = _x + _y; + assert(z >= _x); + return z; + } + + /** + @dev returns the difference of _x minus _y, asserts if the subtraction results in a negative number + + @param _x minuend + @param _y subtrahend + + @return difference + */ + function safeSub(uint256 _x, uint256 _y) internal pure returns (uint256) { + assert(_x >= _y); + return _x - _y; + } + + /** + @dev returns the product of multiplying _x by _y, asserts if the calculation overflows + + @param _x factor 1 + @param _y factor 2 + + @return product + */ + function safeMul(uint256 _x, uint256 _y) internal pure returns (uint256) { + uint256 z = _x * _y; + assert(_x == 0 || z / _x == _y); + return z; + } +} + +/* + Owned contract interface +*/ +contract IOwned { + // this function isn't abstract since the compiler emits automatically generated getter functions as external + function owner() public view returns (address) {} + + function transferOwnership(address _newOwner) public; + function acceptOwnership() public; +} + +/* + Provides support and utilities for contract ownership +*/ +contract Owned is IOwned { + address public owner; + address public newOwner; + + event OwnerUpdate(address indexed _prevOwner, address indexed _newOwner); + + /** + @dev constructor + */ + function Owned() public { + owner = msg.sender; + } + + // allows execution by the owner only + modifier ownerOnly { + assert(msg.sender == owner); + _; + } + + /** + @dev allows transferring the contract ownership + the new owner still needs to accept the transfer + can only be called by the contract owner + + @param _newOwner new contract owner + */ + function transferOwnership(address _newOwner) public ownerOnly { + require(_newOwner != owner); + newOwner = _newOwner; + } + + /** + @dev used by a new owner to accept an ownership transfer + */ + function acceptOwnership() public { + require(msg.sender == newOwner); + OwnerUpdate(owner, newOwner); + owner = newOwner; + newOwner = address(0); + } +} + +/* + Provides support and utilities for contract management +*/ +contract Managed { + address public manager; + address public newManager; + + event ManagerUpdate(address indexed _prevManager, address indexed _newManager); + + /** + @dev constructor + */ + function Managed() public { + manager = msg.sender; + } + + // allows execution by the manager only + modifier managerOnly { + assert(msg.sender == manager); + _; + } + + /** + @dev allows transferring the contract management + the new manager still needs to accept the transfer + can only be called by the contract manager + + @param _newManager new contract manager + */ + function transferManagement(address _newManager) public managerOnly { + require(_newManager != manager); + newManager = _newManager; + } + + /** + @dev used by a new manager to accept a management transfer + */ + function acceptManagement() public { + require(msg.sender == newManager); + ManagerUpdate(manager, newManager); + manager = newManager; + newManager = address(0); + } +} + +/* + ERC20 Standard Token interface +*/ +contract IERC20Token { + // these functions aren't abstract since the compiler emits automatically generated getter functions as external + function name() public view returns (string) {} + function symbol() public view returns (string) {} + function decimals() public view returns (uint8) {} + function totalSupply() public view returns (uint256) {} + function balanceOf(address _owner) public view returns (uint256) { _owner; } + function allowance(address _owner, address _spender) public view returns (uint256) { _owner; _spender; } + + function transfer(address _to, uint256 _value) public returns (bool success); + function transferFrom(address _from, address _to, uint256 _value) public returns (bool success); + function approve(address _spender, uint256 _value) public returns (bool success); +} + +/* + Smart Token interface +*/ +contract ISmartToken is IOwned, IERC20Token { + function disableTransfers(bool _disable) public; + function issue(address _to, uint256 _amount) public; + function destroy(address _from, uint256 _amount) public; +} + +/* + Token Holder interface +*/ +contract ITokenHolder is IOwned { + function withdrawTokens(IERC20Token _token, address _to, uint256 _amount) public; +} + +/* + We consider every contract to be a 'token holder' since it's currently not possible + for a contract to deny receiving tokens. + + The TokenHolder's contract sole purpose is to provide a safety mechanism that allows + the owner to send tokens that were sent to the contract by mistake back to their sender. +*/ +contract TokenHolder is ITokenHolder, Owned, Utils { + /** + @dev constructor + */ + function TokenHolder() public { + } + + /** + @dev withdraws tokens held by the contract and sends them to an account + can only be called by the owner + + @param _token ERC20 token contract address + @param _to account to receive the new amount + @param _amount amount to withdraw + */ + function withdrawTokens(IERC20Token _token, address _to, uint256 _amount) + public + ownerOnly + validAddress(_token) + validAddress(_to) + notThis(_to) + { + assert(_token.transfer(_to, _amount)); + } +} + +/* + The smart token controller is an upgradable part of the smart token that allows + more functionality as well as fixes for bugs/exploits. + Once it accepts ownership of the token, it becomes the token's sole controller + that can execute any of its functions. + + To upgrade the controller, ownership must be transferred to a new controller, along with + any relevant data. + + The smart token must be set on construction and cannot be changed afterwards. + Wrappers are provided (as opposed to a single 'execute' function) for each of the token's functions, for easier access. + + Note that the controller can transfer token ownership to a new controller that + doesn't allow executing any function on the token, for a trustless solution. + Doing that will also remove the owner's ability to upgrade the controller. +*/ +contract SmartTokenController is TokenHolder { + ISmartToken public token; // smart token + + /** + @dev constructor + */ + function SmartTokenController(ISmartToken _token) + public + validAddress(_token) + { + token = _token; + } + + // ensures that the controller is the token's owner + modifier active() { + assert(token.owner() == address(this)); + _; + } + + // ensures that the controller is not the token's owner + modifier inactive() { + assert(token.owner() != address(this)); + _; + } + + /** + @dev allows transferring the token ownership + the new owner still need to accept the transfer + can only be called by the contract owner + + @param _newOwner new token owner + */ + function transferTokenOwnership(address _newOwner) public ownerOnly { + token.transferOwnership(_newOwner); + } + + /** + @dev used by a new owner to accept a token ownership transfer + can only be called by the contract owner + */ + function acceptTokenOwnership() public ownerOnly { + token.acceptOwnership(); + } + + /** + @dev disables/enables token transfers + can only be called by the contract owner + + @param _disable true to disable transfers, false to enable them + */ + function disableTokenTransfers(bool _disable) public ownerOnly { + token.disableTransfers(_disable); + } + + /** + @dev withdraws tokens held by the controller and sends them to an account + can only be called by the owner + + @param _token ERC20 token contract address + @param _to account to receive the new amount + @param _amount amount to withdraw + */ + function withdrawFromToken( + IERC20Token _token, + address _to, + uint256 _amount + ) + public + ownerOnly + { + ITokenHolder(token).withdrawTokens(_token, _to, _amount); + } +} + +/* + Bancor Formula interface +*/ +contract IBancorFormula { + function calculatePurchaseReturn(uint256 _supply, uint256 _connectorBalance, uint32 _connectorWeight, uint256 _depositAmount) public view returns (uint256); + function calculateSaleReturn(uint256 _supply, uint256 _connectorBalance, uint32 _connectorWeight, uint256 _sellAmount) public view returns (uint256); + function calculateCrossConnectorReturn(uint256 _connector1Balance, uint32 _connector1Weight, uint256 _connector2Balance, uint32 _connector2Weight, uint256 _amount) public view returns (uint256); +} + +/* + Bancor Gas Price Limit interface +*/ +contract IBancorGasPriceLimit { + function gasPrice() public view returns (uint256) {} + function validateGasPrice(uint256) public view; +} + +/* + Bancor Quick Converter interface +*/ +contract IBancorQuickConverter { + function convert(IERC20Token[] _path, uint256 _amount, uint256 _minReturn) public payable returns (uint256); + function convertFor(IERC20Token[] _path, uint256 _amount, uint256 _minReturn, address _for) public payable returns (uint256); + function convertForPrioritized(IERC20Token[] _path, uint256 _amount, uint256 _minReturn, address _for, uint256 _block, uint256 _nonce, uint8 _v, bytes32 _r, bytes32 _s) public payable returns (uint256); +} + +/* + Bancor Converter Extensions interface +*/ +contract IBancorConverterExtensions { + function formula() public view returns (IBancorFormula) {} + function gasPriceLimit() public view returns (IBancorGasPriceLimit) {} + function quickConverter() public view returns (IBancorQuickConverter) {} +} + +/* + EIP228 Token Converter interface +*/ +contract ITokenConverter { + function convertibleTokenCount() public view returns (uint16); + function convertibleToken(uint16 _tokenIndex) public view returns (address); + function getReturn(IERC20Token _fromToken, IERC20Token _toToken, uint256 _amount) public view returns (uint256); + function convert(IERC20Token _fromToken, IERC20Token _toToken, uint256 _amount, uint256 _minReturn) public returns (uint256); + // deprecated, backward compatibility + function change(IERC20Token _fromToken, IERC20Token _toToken, uint256 _amount, uint256 _minReturn) public returns (uint256); +} + +/* + Bancor Converter v0.8 + + The Bancor version of the token converter, allows conversion between a smart token and other ERC20 tokens and between different ERC20 tokens and themselves. + + ERC20 connector balance can be virtual, meaning that the calculations are based on the virtual balance instead of relying on + the actual connector balance. This is a security mechanism that prevents the need to keep a very large (and valuable) balance in a single contract. + + The converter is upgradable (just like any SmartTokenController). + + WARNING: It is NOT RECOMMENDED to use the converter with Smart Tokens that have less than 8 decimal digits + or with very small numbers because of precision loss + + + Open issues: + - Front-running attacks are currently mitigated by the following mechanisms: + - minimum return argument for each conversion provides a way to define a minimum/maximum price for the transaction + - gas price limit prevents users from having control over the order of execution + Other potential solutions might include a commit/reveal based schemes + - Possibly add getters for the connector fields so that the client won't need to rely on the order in the struct +*/ +contract BancorConverter is ITokenConverter, SmartTokenController, Managed { + uint32 private constant MAX_WEIGHT = 1000000; + uint32 private constant MAX_CONVERSION_FEE = 1000000; + + struct Connector { + uint256 virtualBalance; // connector virtual balance + uint32 weight; // connector weight, represented in ppm, 1-1000000 + bool isVirtualBalanceEnabled; // true if virtual balance is enabled, false if not + bool isPurchaseEnabled; // is purchase of the smart token enabled with the connector, can be set by the owner + bool isSet; // used to tell if the mapping element is defined + } + + string public version = '0.8'; + string public converterType = 'bancor'; + + IBancorConverterExtensions public extensions; // bancor converter extensions contract + IERC20Token[] public connectorTokens; // ERC20 standard token addresses + IERC20Token[] public quickBuyPath; // conversion path that's used in order to buy the token with ETH + mapping (address => Connector) public connectors; // connector token addresses -> connector data + uint32 private totalConnectorWeight = 0; // used to efficiently prevent increasing the total connector weight above 100% + uint32 public maxConversionFee = 0; // maximum conversion fee for the lifetime of the contract, represented in ppm, 0...1000000 (0 = no fee, 100 = 0.01%, 1000000 = 100%) + uint32 public conversionFee = 0; // current conversion fee, represented in ppm, 0...maxConversionFee + bool public conversionsEnabled = true; // true if token conversions is enabled, false if not + IERC20Token[] private convertPath; + + // triggered when a conversion between two tokens occurs (TokenConverter event) + event Conversion(address indexed _fromToken, address indexed _toToken, address indexed _trader, uint256 _amount, uint256 _return, + int256 _conversionFee, uint256 _currentPriceN, uint256 _currentPriceD); + // triggered when the conversion fee is updated + event ConversionFeeUpdate(uint32 _prevFee, uint32 _newFee); + + /** + @dev constructor + + @param _token smart token governed by the converter + @param _extensions address of a bancor converter extensions contract + @param _maxConversionFee maximum conversion fee, represented in ppm + @param _connectorToken optional, initial connector, allows defining the first connector at deployment time + @param _connectorWeight optional, weight for the initial connector + */ + function BancorConverter(ISmartToken _token, IBancorConverterExtensions _extensions, uint32 _maxConversionFee, IERC20Token _connectorToken, uint32 _connectorWeight) + public + SmartTokenController(_token) + validAddress(_extensions) + validMaxConversionFee(_maxConversionFee) + { + extensions = _extensions; + maxConversionFee = _maxConversionFee; + + if (_connectorToken != address(0)) + addConnector(_connectorToken, _connectorWeight, false); + } + + // validates a connector token address - verifies that the address belongs to one of the connector tokens + modifier validConnector(IERC20Token _address) { + require(connectors[_address].isSet); + _; + } + + // validates a token address - verifies that the address belongs to one of the convertible tokens + modifier validToken(IERC20Token _address) { + require(_address == token || connectors[_address].isSet); + _; + } + + // validates maximum conversion fee + modifier validMaxConversionFee(uint32 _conversionFee) { + require(_conversionFee >= 0 && _conversionFee <= MAX_CONVERSION_FEE); + _; + } + + // validates conversion fee + modifier validConversionFee(uint32 _conversionFee) { + require(_conversionFee >= 0 && _conversionFee <= maxConversionFee); + _; + } + + // validates connector weight range + modifier validConnectorWeight(uint32 _weight) { + require(_weight > 0 && _weight <= MAX_WEIGHT); + _; + } + + // validates a conversion path - verifies that the number of elements is odd and that maximum number of 'hops' is 10 + modifier validConversionPath(IERC20Token[] _path) { + require(_path.length > 2 && _path.length <= (1 + 2 * 10) && _path.length % 2 == 1); + _; + } + + // allows execution only when conversions aren't disabled + modifier conversionsAllowed { + assert(conversionsEnabled); + _; + } + + // allows execution only for owner or manager + modifier ownerOrManagerOnly { + require(msg.sender == owner || msg.sender == manager); + _; + } + + // allows execution only for quick convreter + modifier quickConverterOnly { + require(msg.sender == address(extensions.quickConverter())); + _; + } + + /** + @dev returns the number of connector tokens defined + + @return number of connector tokens + */ + function connectorTokenCount() public view returns (uint16) { + return uint16(connectorTokens.length); + } + + /** + @dev returns the number of convertible tokens supported by the contract + note that the number of convertible tokens is the number of connector token, plus 1 (that represents the smart token) + + @return number of convertible tokens + */ + function convertibleTokenCount() public view returns (uint16) { + return connectorTokenCount() + 1; + } + + /** + @dev given a convertible token index, returns its contract address + + @param _tokenIndex convertible token index + + @return convertible token address + */ + function convertibleToken(uint16 _tokenIndex) public view returns (address) { + if (_tokenIndex == 0) + return token; + return connectorTokens[_tokenIndex - 1]; + } + + /* + @dev allows the owner to update the extensions contract address + + @param _extensions address of a bancor converter extensions contract + */ + function setExtensions(IBancorConverterExtensions _extensions) + public + ownerOnly + validAddress(_extensions) + notThis(_extensions) + { + extensions = _extensions; + } + + /* + @dev allows the manager to update the quick buy path + + @param _path new quick buy path, see conversion path format in the BancorQuickConverter contract + */ + function setQuickBuyPath(IERC20Token[] _path) + public + ownerOnly + validConversionPath(_path) + { + quickBuyPath = _path; + } + + /* + @dev allows the manager to clear the quick buy path + */ + function clearQuickBuyPath() public ownerOnly { + quickBuyPath.length = 0; + } + + /** + @dev returns the length of the quick buy path array + + @return quick buy path length + */ + function getQuickBuyPathLength() public view returns (uint256) { + return quickBuyPath.length; + } + + /** + @dev disables the entire conversion functionality + this is a safety mechanism in case of a emergency + can only be called by the manager + + @param _disable true to disable conversions, false to re-enable them + */ + function disableConversions(bool _disable) public ownerOrManagerOnly { + conversionsEnabled = !_disable; + } + + /** + @dev updates the current conversion fee + can only be called by the manager + + @param _conversionFee new conversion fee, represented in ppm + */ + function setConversionFee(uint32 _conversionFee) + public + ownerOrManagerOnly + validConversionFee(_conversionFee) + { + ConversionFeeUpdate(conversionFee, _conversionFee); + conversionFee = _conversionFee; + } + + /* + @dev returns the conversion fee amount for a given return amount + + @return conversion fee amount + */ + function getConversionFeeAmount(uint256 _amount) public view returns (uint256) { + return safeMul(_amount, conversionFee) / MAX_CONVERSION_FEE; + } + + /** + @dev defines a new connector for the token + can only be called by the owner while the converter is inactive + + @param _token address of the connector token + @param _weight constant connector weight, represented in ppm, 1-1000000 + @param _enableVirtualBalance true to enable virtual balance for the connector, false to disable it + */ + function addConnector(IERC20Token _token, uint32 _weight, bool _enableVirtualBalance) + public + ownerOnly + inactive + validAddress(_token) + notThis(_token) + validConnectorWeight(_weight) + { + require(_token != token && !connectors[_token].isSet && totalConnectorWeight + _weight <= MAX_WEIGHT); // validate input + + connectors[_token].virtualBalance = 0; + connectors[_token].weight = _weight; + connectors[_token].isVirtualBalanceEnabled = _enableVirtualBalance; + connectors[_token].isPurchaseEnabled = true; + connectors[_token].isSet = true; + connectorTokens.push(_token); + totalConnectorWeight += _weight; + } + + /** + @dev updates one of the token connectors + can only be called by the owner + + @param _connectorToken address of the connector token + @param _weight constant connector weight, represented in ppm, 1-1000000 + @param _enableVirtualBalance true to enable virtual balance for the connector, false to disable it + @param _virtualBalance new connector's virtual balance + */ + function updateConnector(IERC20Token _connectorToken, uint32 _weight, bool _enableVirtualBalance, uint256 _virtualBalance) + public + ownerOnly + validConnector(_connectorToken) + validConnectorWeight(_weight) + { + Connector storage connector = connectors[_connectorToken]; + require(totalConnectorWeight - connector.weight + _weight <= MAX_WEIGHT); // validate input + + totalConnectorWeight = totalConnectorWeight - connector.weight + _weight; + connector.weight = _weight; + connector.isVirtualBalanceEnabled = _enableVirtualBalance; + connector.virtualBalance = _virtualBalance; + } + + /** + @dev disables purchasing with the given connector token in case the connector token got compromised + can only be called by the owner + note that selling is still enabled regardless of this flag and it cannot be disabled by the owner + + @param _connectorToken connector token contract address + @param _disable true to disable the token, false to re-enable it + */ + function disableConnectorPurchases(IERC20Token _connectorToken, bool _disable) + public + ownerOnly + validConnector(_connectorToken) + { + connectors[_connectorToken].isPurchaseEnabled = !_disable; + } + + /** + @dev returns the connector's virtual balance if one is defined, otherwise returns the actual balance + + @param _connectorToken connector token contract address + + @return connector balance + */ + function getConnectorBalance(IERC20Token _connectorToken) + public + view + validConnector(_connectorToken) + returns (uint256) + { + Connector storage connector = connectors[_connectorToken]; + return connector.isVirtualBalanceEnabled ? connector.virtualBalance : _connectorToken.balanceOf(this); + } + + /** + @dev returns the expected return for converting a specific amount of _fromToken to _toToken + + @param _fromToken ERC20 token to convert from + @param _toToken ERC20 token to convert to + @param _amount amount to convert, in fromToken + + @return expected conversion return amount + */ + function getReturn(IERC20Token _fromToken, IERC20Token _toToken, uint256 _amount) public view returns (uint256) { + require(_fromToken != _toToken); // validate input + + // conversion between the token and one of its connectors + if (_toToken == token) + return getPurchaseReturn(_fromToken, _amount); + else if (_fromToken == token) + return getSaleReturn(_toToken, _amount); + + // conversion between 2 connectors + uint256 purchaseReturnAmount = getPurchaseReturn(_fromToken, _amount); + return getSaleReturn(_toToken, purchaseReturnAmount, safeAdd(token.totalSupply(), purchaseReturnAmount)); + } + + /** + @dev returns the expected return for buying the token for a connector token + + @param _connectorToken connector token contract address + @param _depositAmount amount to deposit (in the connector token) + + @return expected purchase return amount + */ + function getPurchaseReturn(IERC20Token _connectorToken, uint256 _depositAmount) + public + view + active + validConnector(_connectorToken) + returns (uint256) + { + Connector storage connector = connectors[_connectorToken]; + require(connector.isPurchaseEnabled); // validate input + + uint256 tokenSupply = token.totalSupply(); + uint256 connectorBalance = getConnectorBalance(_connectorToken); + uint256 amount = extensions.formula().calculatePurchaseReturn(tokenSupply, connectorBalance, connector.weight, _depositAmount); + + // deduct the fee from the return amount + uint256 feeAmount = getConversionFeeAmount(amount); + return safeSub(amount, feeAmount); + } + + /** + @dev returns the expected return for selling the token for one of its connector tokens + + @param _connectorToken connector token contract address + @param _sellAmount amount to sell (in the smart token) + + @return expected sale return amount + */ + function getSaleReturn(IERC20Token _connectorToken, uint256 _sellAmount) public view returns (uint256) { + return getSaleReturn(_connectorToken, _sellAmount, token.totalSupply()); + } + + /** + @dev converts a specific amount of _fromToken to _toToken + + @param _fromToken ERC20 token to convert from + @param _toToken ERC20 token to convert to + @param _amount amount to convert, in fromToken + @param _minReturn if the conversion results in an amount smaller than the minimum return - it is cancelled, must be nonzero + + @return conversion return amount + */ + function convertInternal(IERC20Token _fromToken, IERC20Token _toToken, uint256 _amount, uint256 _minReturn) public quickConverterOnly returns (uint256) { + require(_fromToken != _toToken); // validate input + + // conversion between the token and one of its connectors + if (_toToken == token) + return buy(_fromToken, _amount, _minReturn); + else if (_fromToken == token) + return sell(_toToken, _amount, _minReturn); + + // conversion between 2 connectors + uint256 purchaseAmount = buy(_fromToken, _amount, 1); + return sell(_toToken, purchaseAmount, _minReturn); + } + + /** + @dev converts a specific amount of _fromToken to _toToken + + @param _fromToken ERC20 token to convert from + @param _toToken ERC20 token to convert to + @param _amount amount to convert, in fromToken + @param _minReturn if the conversion results in an amount smaller than the minimum return - it is cancelled, must be nonzero + + @return conversion return amount + */ + function convert(IERC20Token _fromToken, IERC20Token _toToken, uint256 _amount, uint256 _minReturn) public returns (uint256) { + convertPath = [_fromToken, token, _toToken]; + return quickConvert(convertPath, _amount, _minReturn); + } + + /** + @dev buys the token by depositing one of its connector tokens + + @param _connectorToken connector token contract address + @param _depositAmount amount to deposit (in the connector token) + @param _minReturn if the conversion results in an amount smaller than the minimum return - it is cancelled, must be nonzero + + @return buy return amount + */ + function buy(IERC20Token _connectorToken, uint256 _depositAmount, uint256 _minReturn) + internal + conversionsAllowed + greaterThanZero(_minReturn) + returns (uint256) + { + uint256 amount = getPurchaseReturn(_connectorToken, _depositAmount); + require(amount != 0 && amount >= _minReturn); // ensure the trade gives something in return and meets the minimum requested amount + + // update virtual balance if relevant + Connector storage connector = connectors[_connectorToken]; + if (connector.isVirtualBalanceEnabled) + connector.virtualBalance = safeAdd(connector.virtualBalance, _depositAmount); + + // transfer _depositAmount funds from the caller in the connector token + assert(_connectorToken.transferFrom(msg.sender, this, _depositAmount)); + // issue new funds to the caller in the smart token + token.issue(msg.sender, amount); + + dispatchConversionEvent(_connectorToken, _depositAmount, amount, true); + return amount; + } + + /** + @dev sells the token by withdrawing from one of its connector tokens + + @param _connectorToken connector token contract address + @param _sellAmount amount to sell (in the smart token) + @param _minReturn if the conversion results in an amount smaller the minimum return - it is cancelled, must be nonzero + + @return sell return amount + */ + function sell(IERC20Token _connectorToken, uint256 _sellAmount, uint256 _minReturn) + internal + conversionsAllowed + greaterThanZero(_minReturn) + returns (uint256) + { + require(_sellAmount <= token.balanceOf(msg.sender)); // validate input + + uint256 amount = getSaleReturn(_connectorToken, _sellAmount); + require(amount != 0 && amount >= _minReturn); // ensure the trade gives something in return and meets the minimum requested amount + + uint256 tokenSupply = token.totalSupply(); + uint256 connectorBalance = getConnectorBalance(_connectorToken); + // ensure that the trade will only deplete the connector if the total supply is depleted as well + assert(amount < connectorBalance || (amount == connectorBalance && _sellAmount == tokenSupply)); + + // update virtual balance if relevant + Connector storage connector = connectors[_connectorToken]; + if (connector.isVirtualBalanceEnabled) + connector.virtualBalance = safeSub(connector.virtualBalance, amount); + + // destroy _sellAmount from the caller's balance in the smart token + token.destroy(msg.sender, _sellAmount); + // transfer funds to the caller in the connector token + // the transfer might fail if the actual connector balance is smaller than the virtual balance + assert(_connectorToken.transfer(msg.sender, amount)); + + dispatchConversionEvent(_connectorToken, _sellAmount, amount, false); + return amount; + } + + /** + @dev converts the token to any other token in the bancor network by following a predefined conversion path + note that when converting from an ERC20 token (as opposed to a smart token), allowance must be set beforehand + + @param _path conversion path, see conversion path format in the BancorQuickConverter contract + @param _amount amount to convert from (in the initial source token) + @param _minReturn if the conversion results in an amount smaller than the minimum return - it is cancelled, must be nonzero + + @return tokens issued in return + */ + function quickConvert(IERC20Token[] _path, uint256 _amount, uint256 _minReturn) + public + payable + validConversionPath(_path) + returns (uint256) + { + return quickConvertPrioritized(_path, _amount, _minReturn, 0x0, 0x0, 0x0, 0x0, 0x0); + } + + /** + @dev converts the token to any other token in the bancor network by following a predefined conversion path + note that when converting from an ERC20 token (as opposed to a smart token), allowance must be set beforehand + + @param _path conversion path, see conversion path format in the BancorQuickConverter contract + @param _amount amount to convert from (in the initial source token) + @param _minReturn if the conversion results in an amount smaller than the minimum return - it is cancelled, must be nonzero + @param _block if the current block exceeded the given parameter - it is cancelled + @param _nonce the nonce of the sender address + @param _v parameter that can be parsed from the transaction signature + @param _r parameter that can be parsed from the transaction signature + @param _s parameter that can be parsed from the transaction signature + + @return tokens issued in return + */ + function quickConvertPrioritized(IERC20Token[] _path, uint256 _amount, uint256 _minReturn, uint256 _block, uint256 _nonce, uint8 _v, bytes32 _r, bytes32 _s) + public + payable + validConversionPath(_path) + returns (uint256) + { + IERC20Token fromToken = _path[0]; + IBancorQuickConverter quickConverter = extensions.quickConverter(); + + // we need to transfer the source tokens from the caller to the quick converter, + // so it can execute the conversion on behalf of the caller + if (msg.value == 0) { + // not ETH, send the source tokens to the quick converter + // if the token is the smart token, no allowance is required - destroy the tokens from the caller and issue them to the quick converter + if (fromToken == token) { + token.destroy(msg.sender, _amount); // destroy _amount tokens from the caller's balance in the smart token + token.issue(quickConverter, _amount); // issue _amount new tokens to the quick converter + } else { + // otherwise, we assume we already have allowance, transfer the tokens directly to the quick converter + assert(fromToken.transferFrom(msg.sender, quickConverter, _amount)); + } + } + + // execute the conversion and pass on the ETH with the call + return quickConverter.convertForPrioritized.value(msg.value)(_path, _amount, _minReturn, msg.sender, _block, _nonce, _v, _r, _s); + } + + // deprecated, backward compatibility + function change(IERC20Token _fromToken, IERC20Token _toToken, uint256 _amount, uint256 _minReturn) public returns (uint256) { + return convertInternal(_fromToken, _toToken, _amount, _minReturn); + } + + /** + @dev utility, returns the expected return for selling the token for one of its connector tokens, given a total supply override + + @param _connectorToken connector token contract address + @param _sellAmount amount to sell (in the smart token) + @param _totalSupply total token supply, overrides the actual token total supply when calculating the return + + @return sale return amount + */ + function getSaleReturn(IERC20Token _connectorToken, uint256 _sellAmount, uint256 _totalSupply) + private + view + active + validConnector(_connectorToken) + greaterThanZero(_totalSupply) + returns (uint256) + { + Connector storage connector = connectors[_connectorToken]; + uint256 connectorBalance = getConnectorBalance(_connectorToken); + uint256 amount = extensions.formula().calculateSaleReturn(_totalSupply, connectorBalance, connector.weight, _sellAmount); + + // deduct the fee from the return amount + uint256 feeAmount = getConversionFeeAmount(amount); + return safeSub(amount, feeAmount); + } + + /** + @dev helper, dispatches the Conversion event + The function also takes the tokens' decimals into account when calculating the current price + + @param _connectorToken connector token contract address + @param _amount amount purchased/sold (in the source token) + @param _returnAmount amount returned (in the target token) + @param isPurchase true if it's a purchase, false if it's a sale + */ + function dispatchConversionEvent(IERC20Token _connectorToken, uint256 _amount, uint256 _returnAmount, bool isPurchase) private { + Connector storage connector = connectors[_connectorToken]; + + // calculate the new price using the simple price formula + // price = connector balance / (supply * weight) + // weight is represented in ppm, so multiplying by 1000000 + uint256 connectorAmount = safeMul(getConnectorBalance(_connectorToken), MAX_WEIGHT); + uint256 tokenAmount = safeMul(token.totalSupply(), connector.weight); + + // normalize values + uint8 tokenDecimals = token.decimals(); + uint8 connectorTokenDecimals = _connectorToken.decimals(); + if (tokenDecimals != connectorTokenDecimals) { + if (tokenDecimals > connectorTokenDecimals) + connectorAmount = safeMul(connectorAmount, 10 ** uint256(tokenDecimals - connectorTokenDecimals)); + else + tokenAmount = safeMul(tokenAmount, 10 ** uint256(connectorTokenDecimals - tokenDecimals)); + } + + uint256 feeAmount = getConversionFeeAmount(_returnAmount); + // ensure that the fee is capped at 255 bits to prevent overflow when converting it to a signed int + assert(feeAmount <= 2 ** 255); + + if (isPurchase) + Conversion(_connectorToken, token, msg.sender, _amount, _returnAmount, int256(feeAmount), connectorAmount, tokenAmount); + else + Conversion(token, _connectorToken, msg.sender, _amount, _returnAmount, int256(feeAmount), tokenAmount, connectorAmount); + } + + /** + @dev fallback, buys the smart token with ETH + note that the purchase will use the price at the time of the purchase + */ + function() payable public { + quickConvert(quickBuyPath, msg.value, 1); + } +} \ No newline at end of file diff --git a/utils/slither_format/tests/real_world/0xf5ed2dc77f0d1ea7f106ecbd1850e406adc41b51_OceanToken.sol b/utils/slither_format/tests/real_world/0xf5ed2dc77f0d1ea7f106ecbd1850e406adc41b51_OceanToken.sol new file mode 100644 index 000000000..57830e096 --- /dev/null +++ b/utils/slither_format/tests/real_world/0xf5ed2dc77f0d1ea7f106ecbd1850e406adc41b51_OceanToken.sol @@ -0,0 +1,454 @@ +pragma solidity ^0.4.18; + +/** + + Copyright (c) 2018 The Ocean. + + Licensed under the MIT License: https://opensource.org/licenses/MIT. + + Permission is hereby granted, free of charge, to any person obtaining + a copy of this software and associated documentation files (the + "Software"), to deal in the Software without restriction, including + without limitation the rights to use, copy, modify, merge, publish, + distribute, sublicense, and/or sell copies of the Software, and to + permit persons to whom the Software is furnished to do so, subject to + the following conditions: + + The above copyright notice and this permission notice shall be included + in all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY + CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, + TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE + SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +**/ + +/** + * @title Ownable + * @dev The Ownable contract has an owner address, and provides basic authorization control + * functions, this simplifies the implementation of "user permissions". + */ +contract Ownable { + address public owner; + + + event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); + + + /** + * @dev The Ownable constructor sets the original `owner` of the contract to the sender + * account. + */ + function Ownable() public { + owner = msg.sender; + } + + /** + * @dev Throws if called by any account other than the owner. + */ + modifier onlyOwner() { + require(msg.sender == owner); + _; + } + + /** + * @dev Allows the current owner to transfer control of the contract to a newOwner. + * @param newOwner The address to transfer ownership to. + */ + function transferOwnership(address newOwner) public onlyOwner { + require(newOwner != address(0)); + OwnershipTransferred(owner, newOwner); + owner = newOwner; + } + +} + + + +/** + * @title ERC20Basic + * @dev Simpler version of ERC20 interface + * @dev see https://github.com/ethereum/EIPs/issues/179 + */ +contract ERC20Basic { + function totalSupply() public view returns (uint256); + function balanceOf(address who) public view returns (uint256); + function transfer(address to, uint256 value) public returns (bool); + event Transfer(address indexed from, address indexed to, uint256 value); +} + + + + + + + + + + + +/** + * @title SafeMath + * @dev Math operations with safety checks that throw on error + */ +library SafeMath { + + /** + * @dev Multiplies two numbers, throws on overflow. + */ + function mul(uint256 a, uint256 b) internal pure returns (uint256) { + if (a == 0) { + return 0; + } + uint256 c = a * b; + assert(c / a == b); + return c; + } + + /** + * @dev Integer division of two numbers, truncating the quotient. + */ + function div(uint256 a, uint256 b) internal pure returns (uint256) { + // assert(b > 0); // Solidity automatically throws when dividing by 0 + uint256 c = a / b; + // assert(a == b * c + a % b); // There is no case in which this doesn't hold + return c; + } + + /** + * @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend). + */ + function sub(uint256 a, uint256 b) internal pure returns (uint256) { + assert(b <= a); + return a - b; + } + + /** + * @dev Adds two numbers, throws on overflow. + */ + function add(uint256 a, uint256 b) internal pure returns (uint256) { + uint256 c = a + b; + assert(c >= a); + return c; + } +} + + + +/** + * @title Basic token + * @dev Basic version of StandardToken, with no allowances. + */ +contract BasicToken is ERC20Basic { + using SafeMath for uint256; + + mapping(address => uint256) balances; + + uint256 totalSupply_; + + /** + * @dev total number of tokens in existence + */ + function totalSupply() public view returns (uint256) { + return totalSupply_; + } + + /** + * @dev transfer token for a specified address + * @param _to The address to transfer to. + * @param _value The amount to be transferred. + */ + function transfer(address _to, uint256 _value) public returns (bool) { + require(_to != address(0)); + require(_value <= balances[msg.sender]); + + // SafeMath.sub will throw if there is not enough balance. + balances[msg.sender] = balances[msg.sender].sub(_value); + balances[_to] = balances[_to].add(_value); + Transfer(msg.sender, _to, _value); + return true; + } + + /** + * @dev Gets the balance of the specified address. + * @param _owner The address to query the the balance of. + * @return An uint256 representing the amount owned by the passed address. + */ + function balanceOf(address _owner) public view returns (uint256 balance) { + return balances[_owner]; + } + +} + + + + + + +/** + * @title ERC20 interface + * @dev see https://github.com/ethereum/EIPs/issues/20 + */ +contract ERC20 is ERC20Basic { + function allowance(address owner, address spender) public view returns (uint256); + function transferFrom(address from, address to, uint256 value) public returns (bool); + function approve(address spender, uint256 value) public returns (bool); + event Approval(address indexed owner, address indexed spender, uint256 value); +} + + + +/** + * @title Standard ERC20 token + * + * @dev Implementation of the basic standard token. + * @dev https://github.com/ethereum/EIPs/issues/20 + * @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol + */ +contract StandardToken is ERC20, BasicToken { + + mapping (address => mapping (address => uint256)) internal allowed; + + + /** + * @dev Transfer tokens from one address to another + * @param _from address The address which you want to send tokens from + * @param _to address The address which you want to transfer to + * @param _value uint256 the amount of tokens to be transferred + */ + function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { + require(_to != address(0)); + require(_value <= balances[_from]); + require(_value <= allowed[_from][msg.sender]); + + balances[_from] = balances[_from].sub(_value); + balances[_to] = balances[_to].add(_value); + allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); + Transfer(_from, _to, _value); + return true; + } + + /** + * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender. + * + * Beware that changing an allowance with this method brings the risk that someone may use both the old + * and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this + * race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards: + * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 + * @param _spender The address which will spend the funds. + * @param _value The amount of tokens to be spent. + */ + function approve(address _spender, uint256 _value) public returns (bool) { + allowed[msg.sender][_spender] = _value; + Approval(msg.sender, _spender, _value); + return true; + } + + /** + * @dev Function to check the amount of tokens that an owner allowed to a spender. + * @param _owner address The address which owns the funds. + * @param _spender address The address which will spend the funds. + * @return A uint256 specifying the amount of tokens still available for the spender. + */ + function allowance(address _owner, address _spender) public view returns (uint256) { + return allowed[_owner][_spender]; + } + + /** + * @dev Increase the amount of tokens that an owner allowed to a spender. + * + * approve should be called when allowed[_spender] == 0. To increment + * allowed value is better to use this function to avoid 2 calls (and wait until + * the first transaction is mined) + * From MonolithDAO Token.sol + * @param _spender The address which will spend the funds. + * @param _addedValue The amount of tokens to increase the allowance by. + */ + function increaseApproval(address _spender, uint _addedValue) public returns (bool) { + allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue); + Approval(msg.sender, _spender, allowed[msg.sender][_spender]); + return true; + } + + /** + * @dev Decrease the amount of tokens that an owner allowed to a spender. + * + * approve should be called when allowed[_spender] == 0. To decrement + * allowed value is better to use this function to avoid 2 calls (and wait until + * the first transaction is mined) + * From MonolithDAO Token.sol + * @param _spender The address which will spend the funds. + * @param _subtractedValue The amount of tokens to decrease the allowance by. + */ + function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) { + uint oldValue = allowed[msg.sender][_spender]; + if (_subtractedValue > oldValue) { + allowed[msg.sender][_spender] = 0; + } else { + allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue); + } + Approval(msg.sender, _spender, allowed[msg.sender][_spender]); + return true; + } + +} + + + + + + + + + + + +/** + * @title Whitelist + * @dev The Whitelist contract has a whitelist of addresses, and provides basic authorization control functions. + * @dev This simplifies the implementation of "user permissions". + */ +contract Whitelist is Ownable { + mapping(address => bool) public whitelist; + + event WhitelistedAddressAdded(address addr); + event WhitelistedAddressRemoved(address addr); + + /** + * @dev Throws if called by any account that's not whitelisted. + */ + modifier onlyWhitelisted() { + require(whitelist[msg.sender]); + _; + } + + /** + * @dev add an address to the whitelist + * @param addr address + * @return true if the address was added to the whitelist, false if the address was already in the whitelist + */ + function addAddressToWhitelist(address addr) onlyOwner public returns(bool success) { + if (!whitelist[addr]) { + whitelist[addr] = true; + WhitelistedAddressAdded(addr); + success = true; + } + } + + /** + * @dev add addresses to the whitelist + * @param addrs addresses + * @return true if at least one address was added to the whitelist, + * false if all addresses were already in the whitelist + */ + function addAddressesToWhitelist(address[] addrs) onlyOwner public returns(bool success) { + for (uint256 i = 0; i < addrs.length; i++) { + if (addAddressToWhitelist(addrs[i])) { + success = true; + } + } + } + + /** + * @dev remove an address from the whitelist + * @param addr address + * @return true if the address was removed from the whitelist, + * false if the address wasn't in the whitelist in the first place + */ + function removeAddressFromWhitelist(address addr) onlyOwner public returns(bool success) { + if (whitelist[addr]) { + whitelist[addr] = false; + WhitelistedAddressRemoved(addr); + success = true; + } + } + + /** + * @dev remove addresses from the whitelist + * @param addrs addresses + * @return true if at least one address was removed from the whitelist, + * false if all addresses weren't in the whitelist in the first place + */ + function removeAddressesFromWhitelist(address[] addrs) onlyOwner public returns(bool success) { + for (uint256 i = 0; i < addrs.length; i++) { + if (removeAddressFromWhitelist(addrs[i])) { + success = true; + } + } + } + +} + + +contract OceanTokenTransferManager is Ownable, Whitelist { + + /** + * @dev check if transferFrom is possible + * @param _from address The address which you want to send tokens from + * @param _to address The address which you want to transfer to + */ + function canTransferFrom(address _from, address _to) public constant returns (bool success) { + if (whitelist[_from] == true || whitelist[_to] == true) { + return true; + } else { + return false; + } + } +} + + +contract OceanToken is StandardToken, Ownable { + event Airdrop(address indexed _to, uint256 _amount); + + string public constant name = 'The Ocean Token'; + string public constant symbol = 'OCEAN'; + uint8 public constant decimals = 18; + + OceanTokenTransferManager public transferManagerContract; + + /** + * @dev Airdrop the specified amount to the address + * @param _to The address that will receive the airdropped tokens. + * @param _requestedAmount The amount of tokens to airdrop. + * @return A boolean that indicates if the operation was successful. + */ + function airdrop(address _to, uint256 _requestedAmount) onlyOwner public returns (bool) { + uint256 _amountToDrop = _requestedAmount; + + totalSupply_ = totalSupply_.add(_amountToDrop); + balances[_to] = balances[_to].add(_amountToDrop); + emit Airdrop(_to, _amountToDrop); + emit Transfer(address(0), _to, _amountToDrop); + + return true; + } + + /** + * @dev Transfer tokens from one address to another + * @param _from address The address which you want to send tokens from + * @param _to address The address which you want to transfer to + * @param _value uint256 the amount of tokens to be transferred + */ + function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { + require(_to != address(0)); + require(_value <= balances[_from]); + require(_value <= allowed[_from][msg.sender]); + + // trading possible when at least one from list [_from, _to] is whitelisted + require(transferManagerContract.canTransferFrom(_from, _to)); + + balances[_from] = balances[_from].sub(_value); + balances[_to] = balances[_to].add(_value); + allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); + emit Transfer(_from, _to, _value); + return true; + } + + function setTransferManagerContract(OceanTokenTransferManager _transferManagerContract) onlyOwner public { + transferManagerContract = _transferManagerContract; + } +} \ No newline at end of file From 32120be4414321bed6c62e70bf36e750d4856017 Mon Sep 17 00:00:00 2001 From: rajeevgopalakrishna Date: Fri, 24 May 2019 11:33:26 +0530 Subject: [PATCH 036/223] Adds use of get_contract_from_name and other loop optimizations. --- .../format_constant_function.py | 13 +- .../format_external_function.py | 22 +- .../format_naming_convention.py | 311 +++++++++--------- 3 files changed, 173 insertions(+), 173 deletions(-) diff --git a/utils/slither_format/format_constant_function.py b/utils/slither_format/format_constant_function.py index b82fc89a2..7be746772 100644 --- a/utils/slither_format/format_constant_function.py +++ b/utils/slither_format/format_constant_function.py @@ -13,13 +13,12 @@ class FormatConstantFunction: if element['type'] != "function": # Skip variable elements continue - Found = False - for contract in slither.contracts: - if not Found: - for function in contract.functions: - if contract.name == element['type_specific_fields']['parent']['name'] and function.name == element['name']: - FormatConstantFunction.create_patch(slither, patches, element['source_mapping']['filename_absolute'], element['source_mapping']['filename_relative'], ["view","pure","constant"], "", int(function.parameters_src.source_mapping['start']), int(function.returns_src.source_mapping['start'])) - Found = True + target_contract = slither.get_contract_from_name(element['type_specific_fields']['parent']['name']) + if target_contract: + for function in target_contract.functions: + if function.name == element['name']: + FormatConstantFunction.create_patch(slither, patches, element['source_mapping']['filename_absolute'], element['source_mapping']['filename_relative'], ["view","pure","constant"], "", int(function.parameters_src.source_mapping['start']), int(function.returns_src.source_mapping['start'])) + break @staticmethod def create_patch(slither, patches, in_file, in_file_relative, match_text, replace_text, modify_loc_start, modify_loc_end): diff --git a/utils/slither_format/format_external_function.py b/utils/slither_format/format_external_function.py index 2ba08cc06..af62025bd 100644 --- a/utils/slither_format/format_external_function.py +++ b/utils/slither_format/format_external_function.py @@ -10,18 +10,16 @@ class FormatExternalFunction: @staticmethod def format (slither, patches, elements): for element in elements: - Found = False - for contract in slither.contracts: - if not Found and contract.name == element['type_specific_fields']['parent']['name']: - for function in contract.functions: - if function.name == element['name']: - # If function parameters are written to in function body then we cannot convert this function - # to external because external function parameters are allocated in calldata region which is - # non-modifiable. See https://solidity.readthedocs.io/en/develop/types.html#data-location - if not FormatExternalFunction.function_parameters_written(function): - FormatExternalFunction.create_patch(slither, patches, element['source_mapping']['filename_absolute'], element['source_mapping']['filename_relative'], "public", "external", int(function.parameters_src.source_mapping['start']), int(function.returns_src.source_mapping['start'])) - Found = True - break + target_contract = slither.get_contract_from_name(element['type_specific_fields']['parent']['name']) + if target_contract: + for function in target_contract.functions: + if function.name == element['name']: + # If function parameters are written to in function body then we cannot convert this function + # to external because external function parameters are allocated in calldata region which is + # non-modifiable. See https://solidity.readthedocs.io/en/develop/types.html#data-location + if not FormatExternalFunction.function_parameters_written(function): + FormatExternalFunction.create_patch(slither, patches, element['source_mapping']['filename_absolute'], element['source_mapping']['filename_relative'], "public", "external", int(function.parameters_src.source_mapping['start']), int(function.returns_src.source_mapping['start'])) + break @staticmethod def create_patch(slither, patches, in_file, in_file_relative, match_text, replace_text, modify_loc_start, modify_loc_end): diff --git a/utils/slither_format/format_naming_convention.py b/utils/slither_format/format_naming_convention.py index 6101f7fa3..aacdd3f82 100644 --- a/utils/slither_format/format_naming_convention.py +++ b/utils/slither_format/format_naming_convention.py @@ -54,31 +54,30 @@ class FormatNamingConvention: @staticmethod def create_patch_contract_definition(slither, patches, name, in_file, in_file_relative, modify_loc_start, modify_loc_end): - for contract in slither.contracts: - if contract.name == name: - in_file_str = slither.source_code[in_file].encode('utf-8') - old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - m = re.match(r'(.*)'+"contract"+r'(.*)'+name, old_str_of_interest.decode('utf-8')) - old_str_of_interest = in_file_str[modify_loc_start:modify_loc_start+m.span()[1]] - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"contract"+r'(.*)'+name, r'\1'+"contract"+r'\2'+name.capitalize(), old_str_of_interest.decode('utf-8'), 1) - if num_repl != 0: - patch = { - "file" : in_file, - "detector" : "naming-convention (contract definition)", - "start":modify_loc_start, - "end":modify_loc_start+m.span()[1], - "old_string":old_str_of_interest.decode('utf-8'), - "new_string":new_str_of_interest - } - if not patch in patches[in_file_relative]: - patches[in_file_relative].append(patch) - else: - logger.error(red("Could not find contract?!")) - sys.exit(-1) + in_file_str = slither.source_code[in_file].encode('utf-8') + old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + m = re.match(r'(.*)'+"contract"+r'(.*)'+name, old_str_of_interest.decode('utf-8')) + old_str_of_interest = in_file_str[modify_loc_start:modify_loc_start+m.span()[1]] + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"contract"+r'(.*)'+name, r'\1'+"contract"+r'\2'+name.capitalize(), old_str_of_interest.decode('utf-8'), 1) + if num_repl != 0: + patch = { + "file" : in_file, + "detector" : "naming-convention (contract definition)", + "start":modify_loc_start, + "end":modify_loc_start+m.span()[1], + "old_string":old_str_of_interest.decode('utf-8'), + "new_string":new_str_of_interest + } + if not patch in patches[in_file_relative]: + patches[in_file_relative].append(patch) + else: + logger.error(red("Could not find contract?!")) + sys.exit(-1) @staticmethod def create_patch_contract_uses(slither, patches, name, in_file, in_file_relative): for contract in slither.contracts: + # Ignore contract definition if contract.name != name: in_file_str = slither.source_code[in_file].encode('utf-8') # Check state variables of contract type @@ -139,90 +138,90 @@ class FormatNamingConvention: else: logger.error(red("Could not find new object?!")) sys.exit(-1) - - else: - # Ignore contract definition - continue @staticmethod def create_patch_modifier_definition(slither, patches, name, contract_name, in_file, in_file_relative, modify_loc_start, modify_loc_end): - for contract in slither.contracts: - if contract.name == contract_name: - for modifier in contract.modifiers: - if modifier.name == name: - in_file_str = slither.source_code[in_file].encode('utf-8') - old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - m = re.match(r'(.*)'+"modifier"+r'(.*)'+name, old_str_of_interest.decode('utf-8')) - old_str_of_interest = in_file_str[modify_loc_start:modify_loc_start+m.span()[1]] - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"modifier"+r'(.*)'+name, r'\1'+"modifier"+r'\2'+name[0].lower()+name[1:], old_str_of_interest.decode('utf-8'), 1) - if num_repl != 0: - patch = { - "file" : in_file, - "detector" : "naming-convention (modifier definition)", - "start" : modify_loc_start, - "end" : modify_loc_start+m.span()[1], - "old_string" : old_str_of_interest.decode('utf-8'), - "new_string" : new_str_of_interest - } - if not patch in patches[in_file_relative]: - patches[in_file_relative].append(patch) - else: - logger.error(red("Could not find modifier?!")) - sys.exit(-1) + target_contract = slither.get_contract_from_name(contract_name) + if not target_contract: + logger.error(red("Contract not found?!")) + sys.exit(-1) + for modifier in target_contract.modifiers: + if modifier.name == name: + in_file_str = slither.source_code[in_file].encode('utf-8') + old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + m = re.match(r'(.*)'+"modifier"+r'(.*)'+name, old_str_of_interest.decode('utf-8')) + old_str_of_interest = in_file_str[modify_loc_start:modify_loc_start+m.span()[1]] + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"modifier"+r'(.*)'+name, r'\1'+"modifier"+r'\2'+name[0].lower()+name[1:], old_str_of_interest.decode('utf-8'), 1) + if num_repl != 0: + patch = { + "file" : in_file, + "detector" : "naming-convention (modifier definition)", + "start" : modify_loc_start, + "end" : modify_loc_start+m.span()[1], + "old_string" : old_str_of_interest.decode('utf-8'), + "new_string" : new_str_of_interest + } + if not patch in patches[in_file_relative]: + patches[in_file_relative].append(patch) + else: + logger.error(red("Could not find modifier?!")) + sys.exit(-1) @staticmethod def create_patch_modifier_uses(slither, patches, name, contract_name, in_file, in_file_relative): - for contract in slither.contracts: - if (contract.name == contract_name): - target_contract = contract - for contract in slither.contracts: - if (contract == target_contract or (contract in target_contract.derived_contracts)): - for function in contract.functions: - for m in function.modifiers: - if (m.name == name): - in_file_str = slither.source_code[in_file].encode('utf-8') - old_str_of_interest = in_file_str[int(function.parameters_src.source_mapping['start']):int(function.returns_src.source_mapping['start'])] - (new_str_of_interest, num_repl) = re.subn(name, name[0].lower()+name[1:],old_str_of_interest.decode('utf-8'),1) - if num_repl != 0: - patch = { - "file" : in_file, - "detector" : "naming-convention (modifier uses)", - "start" : int(function.parameters_src.source_mapping['start']), - "end" : int(function.returns_src.source_mapping['start']), - "old_string" : old_str_of_interest.decode('utf-8'), - "new_string" : new_str_of_interest - } - if not patch in patches[in_file_relative]: - patches[in_file_relative].append(patch) - else: - logger.error(red("Could not find modifier name?!")) - sys.exit(-1) - - @staticmethod - def create_patch_function_definition(slither, patches, name, contract_name, in_file, in_file_relative, modify_loc_start, modify_loc_end): - for contract in slither.contracts: - if contract.name == contract_name: - for function in contract.functions: - if function.name == name: + target_contract = slither.get_contract_from_name(contract_name) + if not target_contract: + logger.error(red("Contract not found?!")) + sys.exit(-1) + for contract in [target_contract] + target_contract.derived_contracts: + for function in contract.functions: + for m in function.modifiers: + if (m.name == name): in_file_str = slither.source_code[in_file].encode('utf-8') - old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - m = re.match(r'(.*)'+"function"+r'\s*'+name, old_str_of_interest.decode('utf-8')) - old_str_of_interest = in_file_str[modify_loc_start:modify_loc_start+m.span()[1]] - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"function"+r'(.*)'+name, r'\1'+"function"+r'\2'+name[0].lower()+name[1:], old_str_of_interest.decode('utf-8'), 1) + old_str_of_interest = in_file_str[int(function.parameters_src.source_mapping['start']):int(function.returns_src.source_mapping['start'])] + (new_str_of_interest, num_repl) = re.subn(name, name[0].lower()+name[1:],old_str_of_interest.decode('utf-8'),1) if num_repl != 0: patch = { "file" : in_file, - "detector" : "naming-convention (function definition)", - "start" : modify_loc_start, - "end" : modify_loc_start+m.span()[1], + "detector" : "naming-convention (modifier uses)", + "start" : int(function.parameters_src.source_mapping['start']), + "end" : int(function.returns_src.source_mapping['start']), "old_string" : old_str_of_interest.decode('utf-8'), "new_string" : new_str_of_interest } - if not patch in patches[in_file_relative]: + if not patch in patches[in_file_relative]: patches[in_file_relative].append(patch) else: - logger.error(red("Could not find function?!")) + logger.error(red("Could not find modifier name?!")) sys.exit(-1) + + @staticmethod + def create_patch_function_definition(slither, patches, name, contract_name, in_file, in_file_relative, modify_loc_start, modify_loc_end): + target_contract = slither.get_contract_from_name(contract_name) + if not target_contract: + logger.error(red("Contract not found?!")) + sys.exit(-1) + for function in target_contract.functions: + if function.name == name: + in_file_str = slither.source_code[in_file].encode('utf-8') + old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + m = re.match(r'(.*)'+"function"+r'\s*'+name, old_str_of_interest.decode('utf-8')) + old_str_of_interest = in_file_str[modify_loc_start:modify_loc_start+m.span()[1]] + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"function"+r'(.*)'+name, r'\1'+"function"+r'\2'+name[0].lower()+name[1:], old_str_of_interest.decode('utf-8'), 1) + if num_repl != 0: + patch = { + "file" : in_file, + "detector" : "naming-convention (function definition)", + "start" : modify_loc_start, + "end" : modify_loc_start+m.span()[1], + "old_string" : old_str_of_interest.decode('utf-8'), + "new_string" : new_str_of_interest + } + if not patch in patches[in_file_relative]: + patches[in_file_relative].append(patch) + else: + logger.error(red("Could not find function?!")) + sys.exit(-1) @staticmethod def create_patch_function_calls(slither, patches, name, contract_name, in_file, in_file_relative): @@ -266,80 +265,84 @@ class FormatNamingConvention: @staticmethod def create_patch_event_definition(slither, patches, name, contract_name, in_file, in_file_relative, modify_loc_start, modify_loc_end): - for contract in slither.contracts: - if contract.name == contract_name: - for event in contract.events: - if event.name == name: - event_name = name.split('(')[0] - in_file_str = slither.source_code[in_file].encode('utf-8') - old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"event"+r'(.*)'+event_name, r'\1'+"event"+r'\2'+event_name[0].capitalize()+event_name[1:], old_str_of_interest.decode('utf-8'), 1) - if num_repl != 0: - patch = { - "file" : in_file, - "detector" : "naming-convention (event definition)", - "start" : modify_loc_start, - "end" : modify_loc_end, - "old_string" : old_str_of_interest.decode('utf-8'), - "new_string" : new_str_of_interest - } - if not patch in patches[in_file_relative]: - patches[in_file_relative].append(patch) - else: - logger.error(red("Could not find event?!")) - sys.exit(-1) + target_contract = slither.get_contract_from_name(contract_name) + if not target_contract: + logger.error(red("Contract not found?!")) + sys.exit(-1) + for event in target_contract.events: + if event.name == name: + event_name = name.split('(')[0] + in_file_str = slither.source_code[in_file].encode('utf-8') + old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"event"+r'(.*)'+event_name, r'\1'+"event"+r'\2'+event_name[0].capitalize()+event_name[1:], old_str_of_interest.decode('utf-8'), 1) + if num_repl != 0: + patch = { + "file" : in_file, + "detector" : "naming-convention (event definition)", + "start" : modify_loc_start, + "end" : modify_loc_end, + "old_string" : old_str_of_interest.decode('utf-8'), + "new_string" : new_str_of_interest + } + if not patch in patches[in_file_relative]: + patches[in_file_relative].append(patch) + else: + logger.error(red("Could not find event?!")) + sys.exit(-1) @staticmethod def create_patch_event_calls(slither, patches, name, contract_name, in_file, in_file_relative): event_name = name.split('(')[0] - for contract in slither.contracts: - if (contract.name == contract_name): - target_contract = contract - for contract in slither.contracts: - if (contract == target_contract or (contract in target_contract.derived_contracts)): - for function in contract.functions: - for node in function.nodes: - for call in node.internal_calls_as_expressions: - if (str(call.called) == event_name): - in_file_str = slither.source_code[in_file].encode('utf-8') - old_str_of_interest = in_file_str[int(call.source_mapping['start']):int(call.source_mapping['start'])+int(call.source_mapping['length'])] - patch = { - "file" : in_file, - "detector" : "naming-convention (event calls)", - "start" : call.source_mapping['start'], - "end" : int(call.source_mapping['start']) + int(call.source_mapping['length']), - "old_string" : old_str_of_interest.decode('utf-8'), - "new_string" : old_str_of_interest.decode('utf-8')[0].capitalize()+old_str_of_interest.decode('utf-8')[1:] - } - if not patch in patches[in_file_relative]: - patches[in_file_relative].append(patch) - - @staticmethod - def create_patch_parameter_declaration(slither, patches, name, function_name, contract_name, in_file, in_file_relative, modify_loc_start, modify_loc_end): - for contract in slither.contracts: - if contract.name == contract_name: - for function in contract.functions: - if function.name == function_name: - in_file_str = slither.source_code[in_file].encode('utf-8') - old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - if(name[0] == '_'): - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+name[0]+name[1].upper()+name[2:]+r'\2', old_str_of_interest.decode('utf-8'), 1) - else: - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+'_'+name[0].upper()+name[1:]+r'\2', old_str_of_interest.decode('utf-8'), 1) - if num_repl != 0: + target_contract = slither.get_contract_from_name(contract_name) + if not target_contract: + logger.error(red("Contract not found?!")) + sys.exit(-1) + for contract in [target_contract] + target_contract.derived_contracts: + for function in contract.functions: + for node in function.nodes: + for call in node.internal_calls_as_expressions: + if (str(call.called) == event_name): + in_file_str = slither.source_code[in_file].encode('utf-8') + old_str_of_interest = in_file_str[int(call.source_mapping['start']):int(call.source_mapping['start'])+int(call.source_mapping['length'])] patch = { "file" : in_file, - "detector" : "naming-convention (parameter declaration)", - "start" : modify_loc_start, - "end" : modify_loc_end, + "detector" : "naming-convention (event calls)", + "start" : call.source_mapping['start'], + "end" : int(call.source_mapping['start']) + int(call.source_mapping['length']), "old_string" : old_str_of_interest.decode('utf-8'), - "new_string" : new_str_of_interest + "new_string" : old_str_of_interest.decode('utf-8')[0].capitalize()+old_str_of_interest.decode('utf-8')[1:] } - if not patch in patches[in_file_relative]: + if not patch in patches[in_file_relative]: patches[in_file_relative].append(patch) - else: - logger.error(red("Could not find parameter declaration?!")) - sys.exit(-1) + + @staticmethod + def create_patch_parameter_declaration(slither, patches, name, function_name, contract_name, in_file, in_file_relative, modify_loc_start, modify_loc_end): + target_contract = slither.get_contract_from_name(contract_name) + if not target_contract: + logger.error(red("Contract not found?!")) + sys.exit(-1) + for function in target_contract.functions: + if function.name == function_name: + in_file_str = slither.source_code[in_file].encode('utf-8') + old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + if(name[0] == '_'): + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+name[0]+name[1].upper()+name[2:]+r'\2', old_str_of_interest.decode('utf-8'), 1) + else: + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+'_'+name[0].upper()+name[1:]+r'\2', old_str_of_interest.decode('utf-8'), 1) + if num_repl != 0: + patch = { + "file" : in_file, + "detector" : "naming-convention (parameter declaration)", + "start" : modify_loc_start, + "end" : modify_loc_end, + "old_string" : old_str_of_interest.decode('utf-8'), + "new_string" : new_str_of_interest + } + if not patch in patches[in_file_relative]: + patches[in_file_relative].append(patch) + else: + logger.error(red("Could not find parameter declaration?!")) + sys.exit(-1) @staticmethod def create_patch_parameter_uses(slither, patches, name, function_name, contract_name, in_file, in_file_relative): From 37cdcc12c51474bde8df433c17dfc134be06da36 Mon Sep 17 00:00:00 2001 From: rajeevgopalakrishna Date: Fri, 24 May 2019 15:03:06 +0530 Subject: [PATCH 037/223] Makes regex stricter for external-function detector. --- .../format_external_function.py | 5 +++-- .../tests/test_data/external_function.sol | 20 +++++++++++++++++ .../tests/test_external_function.py | 22 +++++++++++++------ 3 files changed, 38 insertions(+), 9 deletions(-) diff --git a/utils/slither_format/format_external_function.py b/utils/slither_format/format_external_function.py index af62025bd..031a7947c 100644 --- a/utils/slither_format/format_external_function.py +++ b/utils/slither_format/format_external_function.py @@ -25,8 +25,9 @@ class FormatExternalFunction: def create_patch(slither, patches, in_file, in_file_relative, match_text, replace_text, modify_loc_start, modify_loc_end): in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - m = re.search(" public", old_str_of_interest.decode('utf-8')) + m = re.search(r'((\spublic)\s+)|(\spublic)$|(\)public)$', old_str_of_interest.decode('utf-8')) if m is None: + print("None: " + old_str_of_interest.decode('utf-8')) # No visibility specifier exists; public by default. patches[in_file_relative].append({ "file" : in_file, @@ -41,7 +42,7 @@ class FormatExternalFunction: "file" : in_file, "detector" : "external-function", "start" : modify_loc_start + m.span()[0] + 1, - "end" : modify_loc_start + m.span()[1], + "end" : modify_loc_start + m.span()[0] + 1 + 6, "old_string" : match_text, "new_string" : replace_text }) diff --git a/utils/slither_format/tests/test_data/external_function.sol b/utils/slither_format/tests/test_data/external_function.sol index efaf18e3d..af8037cbe 100644 --- a/utils/slither_format/tests/test_data/external_function.sol +++ b/utils/slither_format/tests/test_data/external_function.sol @@ -99,3 +99,23 @@ contract InternalCall { } } + +contract publicKeywordTest { + + modifier publicMod() { + _; + } + + function test1(uint k) public{ + } + + function test2() publicMod { + } + + function test3() publicMod public { + } + + function test4(uint k)public{ + } + +} diff --git a/utils/slither_format/tests/test_external_function.py b/utils/slither_format/tests/test_external_function.py index 1f3136114..039ebd7c3 100644 --- a/utils/slither_format/tests/test_external_function.py +++ b/utils/slither_format/tests/test_external_function.py @@ -34,11 +34,11 @@ class TestExternalFunctions(unittest.TestCase): for i in range(len(errFD1_lines)): errFD1_lines[i] = errFD1_lines[i].strip() self.assertTrue(os.path.isfile(self.testFilePath1+".format"),"Patched .format file is not created?!") - self.assertEqual(errFD1_lines[0],"INFO:Slither.Format:Number of Slither results: 9") - self.assertEqual(errFD1_lines[1],"INFO:Slither.Format:Number of patches: 8") - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Detector: external-function"), 8) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Old string: public"), 6) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:New string: external"), 6) + self.assertEqual(errFD1_lines[0],"INFO:Slither.Format:Number of Slither results: 13") + self.assertEqual(errFD1_lines[1],"INFO:Slither.Format:Number of patches: 12") + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Detector: external-function"), 12) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Old string: public"), 9) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:New string: external"), 9) self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 384"), 1) self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 390"), 1) self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 562"), 1) @@ -51,12 +51,20 @@ class TestExternalFunctions(unittest.TestCase): self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 1028"), 1) self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 1305"), 1) self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 1311"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Old string:"), 2) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:New string: external"), 2) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 2197"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 2203"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 2275"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 2281"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 2315"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 2321"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Old string:"), 3) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:New string: external"), 3) self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 524"), 1) self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 524"), 1) self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 1142"), 1) self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 1142"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 2228"), 1) + self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 2228"), 1) errFD1.close() errFD2 = open(self.testFilePath2+".err","r") From 9c7f71fa124318971f09772585a10123d5dba613 Mon Sep 17 00:00:00 2001 From: rajeevgopalakrishna Date: Fri, 24 May 2019 17:13:05 +0530 Subject: [PATCH 038/223] Adds multiline formatting changes. --- .../slither_format/format_constable_states.py | 5 +- .../format_constant_function.py | 7 +- .../format_external_function.py | 8 +- .../format_naming_convention.py | 252 +++++++++++++----- utils/slither_format/format_pragma.py | 5 +- utils/slither_format/format_solc_version.py | 8 +- utils/slither_format/format_unused_state.py | 7 +- 7 files changed, 215 insertions(+), 77 deletions(-) diff --git a/utils/slither_format/format_constable_states.py b/utils/slither_format/format_constable_states.py index 6f221fce7..ca0cf9cb2 100644 --- a/utils/slither_format/format_constable_states.py +++ b/utils/slither_format/format_constable_states.py @@ -10,7 +10,10 @@ class FormatConstableStates: @staticmethod def format(slither, patches, elements): for element in elements: - FormatConstableStates.create_patch(slither, patches, element['source_mapping']['filename_absolute'], element['source_mapping']['filename_relative'], element['name'], "constant " + element['name'], element['source_mapping']['start'], element['source_mapping']['start'] + element['source_mapping']['length']) + FormatConstableStates.create_patch(slither, patches, element['source_mapping']['filename_absolute'], \ + element['source_mapping']['filename_relative'], element['name'], \ + "constant " + element['name'], element['source_mapping']['start'], \ + element['source_mapping']['start'] + element['source_mapping']['length']) @staticmethod def create_patch(slither, patches, in_file, in_file_relative, match_text, replace_text, modify_loc_start, modify_loc_end): diff --git a/utils/slither_format/format_constant_function.py b/utils/slither_format/format_constant_function.py index 7be746772..936216f2b 100644 --- a/utils/slither_format/format_constant_function.py +++ b/utils/slither_format/format_constant_function.py @@ -17,7 +17,12 @@ class FormatConstantFunction: if target_contract: for function in target_contract.functions: if function.name == element['name']: - FormatConstantFunction.create_patch(slither, patches, element['source_mapping']['filename_absolute'], element['source_mapping']['filename_relative'], ["view","pure","constant"], "", int(function.parameters_src.source_mapping['start']), int(function.returns_src.source_mapping['start'])) + FormatConstantFunction.create_patch(slither, patches, \ + element['source_mapping']['filename_absolute'], \ + element['source_mapping']['filename_relative'], \ + ["view","pure","constant"], "", \ + int(function.parameters_src.source_mapping['start']), \ + int(function.returns_src.source_mapping['start'])) break @staticmethod diff --git a/utils/slither_format/format_external_function.py b/utils/slither_format/format_external_function.py index 031a7947c..21d4bce27 100644 --- a/utils/slither_format/format_external_function.py +++ b/utils/slither_format/format_external_function.py @@ -18,7 +18,12 @@ class FormatExternalFunction: # to external because external function parameters are allocated in calldata region which is # non-modifiable. See https://solidity.readthedocs.io/en/develop/types.html#data-location if not FormatExternalFunction.function_parameters_written(function): - FormatExternalFunction.create_patch(slither, patches, element['source_mapping']['filename_absolute'], element['source_mapping']['filename_relative'], "public", "external", int(function.parameters_src.source_mapping['start']), int(function.returns_src.source_mapping['start'])) + FormatExternalFunction.create_patch(slither, patches, \ + element['source_mapping']['filename_absolute'], \ + element['source_mapping']['filename_relative'], \ + "public", "external", \ + int(function.parameters_src.source_mapping['start']), \ + int(function.returns_src.source_mapping['start'])) break @staticmethod @@ -27,7 +32,6 @@ class FormatExternalFunction: old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] m = re.search(r'((\spublic)\s+)|(\spublic)$|(\)public)$', old_str_of_interest.decode('utf-8')) if m is None: - print("None: " + old_str_of_interest.decode('utf-8')) # No visibility specifier exists; public by default. patches[in_file_relative].append({ "file" : in_file, diff --git a/utils/slither_format/format_naming_convention.py b/utils/slither_format/format_naming_convention.py index aacdd3f82..2a902a314 100644 --- a/utils/slither_format/format_naming_convention.py +++ b/utils/slither_format/format_naming_convention.py @@ -15,39 +15,77 @@ class FormatNamingConvention: def format(slither, patches, elements): for element in elements: if (element['additional_fields']['target'] == "parameter"): - FormatNamingConvention.create_patch(slither, patches, element['additional_fields']['target'], element['name'], element['type_specific_fields']['parent']['name'], element['type_specific_fields']['parent']['type_specific_fields']['parent']['name'], element['source_mapping']['filename_absolute'], element['source_mapping']['filename_relative'], element['source_mapping']['start'],(element['source_mapping']['start']+element['source_mapping']['length'])) - elif (element['additional_fields']['target'] == "modifier" or element['additional_fields']['target'] == "function" or element['additional_fields']['target'] == "event" or element['additional_fields']['target'] == "variable" or element['additional_fields']['target'] == "variable_constant" or element['additional_fields']['target'] == "enum" or element['additional_fields']['target'] == "structure"): - FormatNamingConvention.create_patch(slither, patches, element['additional_fields']['target'], element['name'], element['name'], element['type_specific_fields']['parent']['name'], element['source_mapping']['filename_absolute'], element['source_mapping']['filename_relative'], element['source_mapping']['start'],(element['source_mapping']['start']+element['source_mapping']['length'])) + FormatNamingConvention.create_patch(slither, patches, element['additional_fields']['target'], \ + element['name'], element['type_specific_fields']['parent']['name'], \ + element['type_specific_fields']['parent']['type_specific_fields'] + ['parent']['name'], element['source_mapping']['filename_absolute'], \ + element['source_mapping']['filename_relative'], \ + element['source_mapping']['start'],(element['source_mapping']['start'] + + element['source_mapping']['length'])) + elif (element['additional_fields']['target'] == "modifier" or + element['additional_fields']['target'] == "function" or + element['additional_fields']['target'] == "event" or + element['additional_fields']['target'] == "variable" or + element['additional_fields']['target'] == "variable_constant" or + element['additional_fields']['target'] == "enum" or + element['additional_fields']['target'] == "structure"): + FormatNamingConvention.create_patch(slither, patches, element['additional_fields']['target'], \ + element['name'], element['name'], \ + element['type_specific_fields']['parent']['name'], \ + element['source_mapping']['filename_absolute'], \ + element['source_mapping']['filename_relative'], \ + element['source_mapping']['start'],(element['source_mapping']['start'] + + element['source_mapping']['length'])) else: - FormatNamingConvention.create_patch(slither, patches, element['additional_fields']['target'], element['name'], element['name'], element['name'], element['source_mapping']['filename_absolute'], element['source_mapping']['filename_relative'], element['source_mapping']['start'],(element['source_mapping']['start']+element['source_mapping']['length'])) + FormatNamingConvention.create_patch(slither, patches, element['additional_fields']['target'], \ + element['name'], element['name'], element['name'], \ + element['source_mapping']['filename_absolute'], \ + element['source_mapping']['filename_relative'], \ + element['source_mapping']['start'],(element['source_mapping']['start'] + + element['source_mapping']['length'])) @staticmethod - def create_patch(slither, patches, _target, name, function_name, contract_name, in_file, in_file_relative, modify_loc_start, modify_loc_end): + def create_patch(slither, patches, _target, name, function_name, contract_name, in_file, in_file_relative, + modify_loc_start, modify_loc_end): if _target == "contract": - FormatNamingConvention.create_patch_contract_definition(slither, patches, name, in_file, in_file_relative, modify_loc_start, modify_loc_end) + FormatNamingConvention.create_patch_contract_definition(slither, patches, name, in_file, in_file_relative, + modify_loc_start, modify_loc_end) FormatNamingConvention.create_patch_contract_uses(slither, patches, name, in_file, in_file_relative) elif _target == "structure": - FormatNamingConvention.create_patch_struct_definition(slither, patches, name, contract_name, in_file, in_file_relative, modify_loc_start, modify_loc_end) + FormatNamingConvention.create_patch_struct_definition(slither, patches, name, contract_name, in_file, + in_file_relative, modify_loc_start, modify_loc_end) FormatNamingConvention.create_patch_struct_uses(slither, patches, name, contract_name, in_file, in_file_relative) elif _target == "event": - FormatNamingConvention.create_patch_event_definition(slither, patches, name, contract_name, in_file, in_file_relative, modify_loc_start, modify_loc_end) + FormatNamingConvention.create_patch_event_definition(slither, patches, name, contract_name, in_file, + in_file_relative, modify_loc_start, modify_loc_end) FormatNamingConvention.create_patch_event_calls(slither, patches, name, contract_name, in_file, in_file_relative) elif _target == "function": if name != contract_name: - FormatNamingConvention.create_patch_function_definition(slither, patches, name, contract_name, in_file, in_file_relative, modify_loc_start, modify_loc_end) - FormatNamingConvention.create_patch_function_calls(slither, patches, name, contract_name, in_file, in_file_relative) + FormatNamingConvention.create_patch_function_definition(slither, patches, name, contract_name, in_file, + in_file_relative, modify_loc_start, modify_loc_end) + FormatNamingConvention.create_patch_function_calls(slither, patches, name, contract_name, in_file, + in_file_relative) elif _target == "parameter": - FormatNamingConvention.create_patch_parameter_declaration(slither, patches, name, function_name, contract_name, in_file, in_file_relative, modify_loc_start, modify_loc_end) - FormatNamingConvention.create_patch_parameter_uses(slither, patches, name, function_name, contract_name, in_file, in_file_relative) + FormatNamingConvention.create_patch_parameter_declaration(slither, patches, name, function_name, contract_name, + in_file, in_file_relative, modify_loc_start, + modify_loc_end) + FormatNamingConvention.create_patch_parameter_uses(slither, patches, name, function_name, contract_name, + in_file, in_file_relative) elif _target == "variable_constant" or _target == "variable": - FormatNamingConvention.create_patch_state_variable_declaration(slither, patches, _target, name, contract_name, in_file, in_file_relative, modify_loc_start, modify_loc_end) - FormatNamingConvention.create_patch_state_variable_uses(slither, patches, _target, name, contract_name, in_file, in_file_relative) + FormatNamingConvention.create_patch_state_variable_declaration(slither, patches, _target, name, contract_name, + in_file, in_file_relative, modify_loc_start, + modify_loc_end) + FormatNamingConvention.create_patch_state_variable_uses(slither, patches, _target, name, contract_name, in_file, + in_file_relative) elif _target == "enum": - FormatNamingConvention.create_patch_enum_definition(slither, patches, name, contract_name, in_file, in_file_relative, modify_loc_start, modify_loc_end) + FormatNamingConvention.create_patch_enum_definition(slither, patches, name, contract_name, in_file, + in_file_relative, modify_loc_start, modify_loc_end) FormatNamingConvention.create_patch_enum_uses(slither, patches, name, contract_name, in_file, in_file_relative) elif _target == "modifier": - FormatNamingConvention.create_patch_modifier_definition(slither, patches, name, contract_name, in_file, in_file_relative, modify_loc_start, modify_loc_end) - FormatNamingConvention.create_patch_modifier_uses(slither, patches, name, contract_name, in_file, in_file_relative) + FormatNamingConvention.create_patch_modifier_definition(slither, patches, name, contract_name, in_file, + in_file_relative, modify_loc_start, modify_loc_end) + FormatNamingConvention.create_patch_modifier_uses(slither, patches, name, contract_name, in_file, + in_file_relative) else: logger.error(red("Unknown naming convention! " + _target)) sys.exit(-1) @@ -58,7 +96,8 @@ class FormatNamingConvention: old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] m = re.match(r'(.*)'+"contract"+r'(.*)'+name, old_str_of_interest.decode('utf-8')) old_str_of_interest = in_file_str[modify_loc_start:modify_loc_start+m.span()[1]] - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"contract"+r'(.*)'+name, r'\1'+"contract"+r'\2'+name.capitalize(), old_str_of_interest.decode('utf-8'), 1) + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"contract"+r'(.*)'+name, r'\1'+"contract"+r'\2'+name.capitalize(), + old_str_of_interest.decode('utf-8'), 1) if num_repl != 0: patch = { "file" : in_file, @@ -85,8 +124,10 @@ class FormatNamingConvention: svs = contract.variables for sv in svs: if (str(sv.type) == name): - old_str_of_interest = in_file_str[sv.source_mapping['start']:(sv.source_mapping['start']+sv.source_mapping['length'])] - (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(),old_str_of_interest.decode('utf-8'), 1) + old_str_of_interest = in_file_str[sv.source_mapping['start']:(sv.source_mapping['start'] + + sv.source_mapping['length'])] + (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(), + old_str_of_interest.decode('utf-8'), 1) patch = { "file" : in_file, "detector" : "naming-convention (contract state variable)", @@ -103,7 +144,9 @@ class FormatNamingConvention: for fm in fms: for v in fm.variables: if (str(v.type) == name): - old_str_of_interest = in_file_str[v.source_mapping['start']:(v.source_mapping['start']+v.source_mapping['length'])].decode('utf-8').split('=')[0] + old_str_of_interest = in_file_str[v.source_mapping['start']:(v.source_mapping['start'] + + v.source_mapping['length'])] + old_str_of_interest = old_str_of_interest.decode('utf-8').split('=')[0] (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(),old_str_of_interest, 1) patch = { "file" : in_file, @@ -120,10 +163,12 @@ class FormatNamingConvention: for node in function.nodes: for ir in node.irs: if isinstance(ir, NewContract) and ir.contract_name == name: - old_str_of_interest = in_file_str[node.source_mapping['start']:node.source_mapping['start'] + node.source_mapping['length']] + old_str_of_interest = in_file_str[node.source_mapping['start']:node.source_mapping['start'] + + node.source_mapping['length']] m = re.search("new"+r'(.*)'+name, old_str_of_interest.decode('utf-8')) old_str_of_interest = old_str_of_interest.decode('utf-8')[m.span()[0]:] - (new_str_of_interest, num_repl) = re.subn("new"+r'(.*)'+name, "new"+r'\1'+name[0].upper()+name[1:], old_str_of_interest, 1) + (new_str_of_interest, num_repl) = re.subn("new"+r'(.*)'+name, "new"+r'\1'+name[0].upper() + + name[1:], old_str_of_interest, 1) if num_repl != 0: patch = { "file" : in_file, @@ -140,7 +185,8 @@ class FormatNamingConvention: sys.exit(-1) @staticmethod - def create_patch_modifier_definition(slither, patches, name, contract_name, in_file, in_file_relative, modify_loc_start, modify_loc_end): + def create_patch_modifier_definition(slither, patches, name, contract_name, in_file, in_file_relative, modify_loc_start, + modify_loc_end): target_contract = slither.get_contract_from_name(contract_name) if not target_contract: logger.error(red("Contract not found?!")) @@ -151,7 +197,8 @@ class FormatNamingConvention: old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] m = re.match(r'(.*)'+"modifier"+r'(.*)'+name, old_str_of_interest.decode('utf-8')) old_str_of_interest = in_file_str[modify_loc_start:modify_loc_start+m.span()[1]] - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"modifier"+r'(.*)'+name, r'\1'+"modifier"+r'\2'+name[0].lower()+name[1:], old_str_of_interest.decode('utf-8'), 1) + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"modifier"+r'(.*)'+name, r'\1'+"modifier"+r'\2' + + name[0].lower()+name[1:], old_str_of_interest.decode('utf-8'), 1) if num_repl != 0: patch = { "file" : in_file, @@ -178,8 +225,10 @@ class FormatNamingConvention: for m in function.modifiers: if (m.name == name): in_file_str = slither.source_code[in_file].encode('utf-8') - old_str_of_interest = in_file_str[int(function.parameters_src.source_mapping['start']):int(function.returns_src.source_mapping['start'])] - (new_str_of_interest, num_repl) = re.subn(name, name[0].lower()+name[1:],old_str_of_interest.decode('utf-8'),1) + old_str_of_interest = in_file_str[int(function.parameters_src.source_mapping['start']): + int(function.returns_src.source_mapping['start'])] + (new_str_of_interest, num_repl) = re.subn(name, name[0].lower()+name[1:], + old_str_of_interest.decode('utf-8'),1) if num_repl != 0: patch = { "file" : in_file, @@ -196,7 +245,8 @@ class FormatNamingConvention: sys.exit(-1) @staticmethod - def create_patch_function_definition(slither, patches, name, contract_name, in_file, in_file_relative, modify_loc_start, modify_loc_end): + def create_patch_function_definition(slither, patches, name, contract_name, in_file, in_file_relative, modify_loc_start, + modify_loc_end): target_contract = slither.get_contract_from_name(contract_name) if not target_contract: logger.error(red("Contract not found?!")) @@ -207,7 +257,8 @@ class FormatNamingConvention: old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] m = re.match(r'(.*)'+"function"+r'\s*'+name, old_str_of_interest.decode('utf-8')) old_str_of_interest = in_file_str[modify_loc_start:modify_loc_start+m.span()[1]] - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"function"+r'(.*)'+name, r'\1'+"function"+r'\2'+name[0].lower()+name[1:], old_str_of_interest.decode('utf-8'), 1) + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"function"+r'(.*)'+name, r'\1'+"function"+r'\2'+ + name[0].lower()+name[1:], old_str_of_interest.decode('utf-8'), 1) if num_repl != 0: patch = { "file" : in_file, @@ -234,15 +285,19 @@ class FormatNamingConvention: called_function = str(external_call.called).split('.')[-1] if called_function == high_level_call[1].name: in_file_str = slither.source_code[in_file].encode('utf-8') - old_str_of_interest = in_file_str[int(external_call.source_mapping['start']):int(external_call.source_mapping['start'])+int(external_call.source_mapping['length'])] + old_str_of_interest = in_file_str[int(external_call.source_mapping['start']): + int(external_call.source_mapping['start']) + + int(external_call.source_mapping['length'])] called_function_name = old_str_of_interest.decode('utf-8').split('.')[-1] fixed_function_name = called_function_name[0].lower() + called_function_name[1:] - new_string = '.'.join(old_str_of_interest.decode('utf-8').split('.')[:-1]) + '.' + fixed_function_name + new_string = '.'.join(old_str_of_interest.decode('utf-8').split('.')[:-1]) + '.' + \ + fixed_function_name patch = { "file" : in_file, "detector" : "naming-convention (function calls)", "start" : external_call.source_mapping['start'], - "end" : int(external_call.source_mapping['start']) + int(external_call.source_mapping['length']), + "end" : int(external_call.source_mapping['start']) + + int(external_call.source_mapping['length']), "old_string" : old_str_of_interest.decode('utf-8'), "new_string" : new_string } @@ -251,12 +306,20 @@ class FormatNamingConvention: for internal_call in node.internal_calls_as_expressions: if (str(internal_call.called) == name): in_file_str = slither.source_code[in_file].encode('utf-8') - old_str_of_interest = in_file_str[int(internal_call.source_mapping['start']):int(internal_call.source_mapping['start'])+int(internal_call.source_mapping['length'])].decode('utf-8').split('(')[0] + old_str_of_interest = in_file_str[int(internal_call.source_mapping['start']): + int(internal_call.source_mapping['start']) + + int(internal_call.source_mapping['length'])] + old_str_of_interest = old_str_of_interest.decode('utf-8').split('(')[0] patch = { "file" : in_file, "detector" : "naming-convention (function calls)", "start" : internal_call.source_mapping['start'], - "end" : int(internal_call.source_mapping['start']) + int(internal_call.source_mapping['length']) - len('('.join(in_file_str[int(internal_call.source_mapping['start']):int(internal_call.source_mapping['start'])+int(internal_call.source_mapping['length'])].decode('utf-8').split('(')[1:])) - 1, + "end" : int(internal_call.source_mapping['start']) + + int(internal_call.source_mapping['length']) - + len('('.join(in_file_str[int(internal_call.source_mapping['start']): + int(internal_call.source_mapping['start']) + + int(internal_call.source_mapping['length'])] \ + .decode('utf-8').split('(')[1:])) - 1, "old_string" : old_str_of_interest, "new_string" : old_str_of_interest[0].lower()+old_str_of_interest[1:] } @@ -264,7 +327,8 @@ class FormatNamingConvention: patches[in_file_relative].append(patch) @staticmethod - def create_patch_event_definition(slither, patches, name, contract_name, in_file, in_file_relative, modify_loc_start, modify_loc_end): + def create_patch_event_definition(slither, patches, name, contract_name, in_file, in_file_relative, modify_loc_start, + modify_loc_end): target_contract = slither.get_contract_from_name(contract_name) if not target_contract: logger.error(red("Contract not found?!")) @@ -274,7 +338,9 @@ class FormatNamingConvention: event_name = name.split('(')[0] in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"event"+r'(.*)'+event_name, r'\1'+"event"+r'\2'+event_name[0].capitalize()+event_name[1:], old_str_of_interest.decode('utf-8'), 1) + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"event"+r'(.*)'+event_name, r'\1'+"event"+r'\2' + + event_name[0].capitalize()+event_name[1:], + old_str_of_interest.decode('utf-8'), 1) if num_repl != 0: patch = { "file" : in_file, @@ -303,20 +369,24 @@ class FormatNamingConvention: for call in node.internal_calls_as_expressions: if (str(call.called) == event_name): in_file_str = slither.source_code[in_file].encode('utf-8') - old_str_of_interest = in_file_str[int(call.source_mapping['start']):int(call.source_mapping['start'])+int(call.source_mapping['length'])] + old_str_of_interest = in_file_str[int(call.source_mapping['start']): + int(call.source_mapping['start']) + + int(call.source_mapping['length'])] patch = { "file" : in_file, "detector" : "naming-convention (event calls)", "start" : call.source_mapping['start'], "end" : int(call.source_mapping['start']) + int(call.source_mapping['length']), "old_string" : old_str_of_interest.decode('utf-8'), - "new_string" : old_str_of_interest.decode('utf-8')[0].capitalize()+old_str_of_interest.decode('utf-8')[1:] + "new_string" : old_str_of_interest.decode('utf-8')[0].capitalize() + + old_str_of_interest.decode('utf-8')[1:] } if not patch in patches[in_file_relative]: patches[in_file_relative].append(patch) @staticmethod - def create_patch_parameter_declaration(slither, patches, name, function_name, contract_name, in_file, in_file_relative, modify_loc_start, modify_loc_end): + def create_patch_parameter_declaration(slither, patches, name, function_name, contract_name, in_file, in_file_relative, + modify_loc_start, modify_loc_end): target_contract = slither.get_contract_from_name(contract_name) if not target_contract: logger.error(red("Contract not found?!")) @@ -326,9 +396,11 @@ class FormatNamingConvention: in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] if(name[0] == '_'): - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+name[0]+name[1].upper()+name[2:]+r'\2', old_str_of_interest.decode('utf-8'), 1) + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+name[0]+name[1].upper() + + name[2:]+r'\2', old_str_of_interest.decode('utf-8'), 1) else: - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+'_'+name[0].upper()+name[1:]+r'\2', old_str_of_interest.decode('utf-8'), 1) + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+'_'+name[0].upper() + + name[1:]+r'\2', old_str_of_interest.decode('utf-8'), 1) if num_repl != 0: patch = { "file" : in_file, @@ -354,14 +426,22 @@ class FormatNamingConvention: for node in function.nodes: vars = node._expression_vars_written + node._expression_vars_read for v in vars: - if isinstance(v, Identifier) and str(v) == name and [str(lv) for lv in (node._local_vars_read+node._local_vars_written) if str(lv) == name]: + if isinstance(v, Identifier) and str(v) == name and [str(lv) for lv in + (node._local_vars_read + + node._local_vars_written) + if str(lv) == name]: modify_loc_start = int(v.source_mapping['start']) modify_loc_end = int(v.source_mapping['start']) + int(v.source_mapping['length']) old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] if(name[0] == '_'): - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+name[0]+name[1].upper()+name[2:]+r'\2', old_str_of_interest.decode('utf-8'), 1) + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', + r'\1'+name[0]+name[1].upper()+name[2:] + + r'\2', old_str_of_interest.decode('utf-8'), + 1) else: - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+'_'+name[0].upper()+name[1:]+r'\2', old_str_of_interest.decode('utf-8'), 1) + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+'_' + + name[0].upper()+name[1:]+r'\2', + old_str_of_interest.decode('utf-8'), 1) if num_repl != 0: patch = { "file" : in_file, @@ -381,17 +461,25 @@ class FormatNamingConvention: for modifier in function._expression_modifiers: for arg in modifier.arguments: if str(arg) == name: - old_str_of_interest = in_file_str[modifier.source_mapping['start']:modifier.source_mapping['start']+modifier.source_mapping['length']] - old_str_of_interest_beyond_modifier_name = old_str_of_interest.decode('utf-8').split('(')[1] + old_str_of_interest = in_file_str[modifier.source_mapping['start']: + modifier.source_mapping['start'] + + modifier.source_mapping['length']] + old_str_of_interest_beyond_modifier_name = old_str_of_interest.decode('utf-8')\ + .split('(')[1] if(name[0] == '_'): - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+name[0]+name[1].upper()+name[2:]+r'\2', old_str_of_interest_beyond_modifier_name, 1) + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+name[0]+ + name[1].upper()+name[2:]+r'\2', + old_str_of_interest_beyond_modifier_name, 1) else: - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+'_'+name[0].upper()+name[1:]+r'\2', old_str_of_interest_beyond_modifier_name, 1) + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+'_'+ + name[0].upper()+name[1:]+r'\2', + old_str_of_interest_beyond_modifier_name, 1) if num_repl != 0: patch = { "file" : in_file, "detector" : "naming-convention (parameter uses)", - "start" : modifier.source_mapping['start'] + len(old_str_of_interest.decode('utf-8').split('(')[0]) + 1, + "start" : modifier.source_mapping['start'] + + len(old_str_of_interest.decode('utf-8').split('(')[0]) + 1, "end" : modifier.source_mapping['start'] + modifier.source_mapping['length'], "old_string" : old_str_of_interest_beyond_modifier_name, "new_string" : new_str_of_interest @@ -403,7 +491,8 @@ class FormatNamingConvention: sys.exit(-1) @staticmethod - def create_patch_state_variable_declaration(slither, patches, _target, name, contract_name, in_file, in_file_relative, modify_loc_start, modify_loc_end): + def create_patch_state_variable_declaration(slither, patches, _target, name, contract_name, in_file, in_file_relative, + modify_loc_start, modify_loc_end): for contract in slither.contracts: if (contract.name == contract_name): for var in contract.state_variables: @@ -440,7 +529,10 @@ class FormatNamingConvention: for node in fm.nodes: vars = node._expression_vars_written + node._expression_vars_read for v in vars: - if isinstance(v, Identifier) and str(v) == name and [str(sv) for sv in (node._state_vars_read+node._state_vars_written) if str(sv) == name]: + if isinstance(v, Identifier) and str(v) == name and [str(sv) for sv in + (node._state_vars_read + + node._state_vars_written) + if str(sv) == name]: modify_loc_start = int(v.source_mapping['start']) modify_loc_end = int(v.source_mapping['start']) + int(v.source_mapping['length']) in_file_str = slither.source_code[in_file].encode('utf-8') @@ -462,14 +554,17 @@ class FormatNamingConvention: patches[in_file_relative].append(patch) @staticmethod - def create_patch_enum_definition(slither, patches, name, contract_name, in_file, in_file_relative, modify_loc_start, modify_loc_end): + def create_patch_enum_definition(slither, patches, name, contract_name, in_file, in_file_relative, modify_loc_start, + modify_loc_end): for contract in slither.contracts: if (contract.name == contract_name): for enum in contract.enums: if (enum.name == name): in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"enum"+r'(.*)'+name, r'\1'+"enum"+r'\2'+name[0].capitalize()+name[1:], old_str_of_interest.decode('utf-8'), 1) + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"enum"+r'(.*)'+name, r'\1'+"enum"+r'\2'+ + name[0].capitalize()+name[1:], + old_str_of_interest.decode('utf-8'), 1) if num_repl != 0: patch = { "file" : in_file, @@ -498,8 +593,10 @@ class FormatNamingConvention: svs = contract.variables for sv in svs: if (str(sv.type) == contract_name + "." + name): - old_str_of_interest = in_file_str[sv.source_mapping['start']:(sv.source_mapping['start']+sv.source_mapping['length'])] - (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(),old_str_of_interest.decode('utf-8'), 1) + old_str_of_interest = in_file_str[sv.source_mapping['start']:(sv.source_mapping['start']+ + sv.source_mapping['length'])] + (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(), + old_str_of_interest.decode('utf-8'), 1) patch = { "file" : in_file, "detector" : "naming-convention (enum use)", @@ -517,8 +614,10 @@ class FormatNamingConvention: # Enum declarations for v in fm.variables: if (str(v.type) == contract_name + "." + name): - old_str_of_interest = in_file_str[v.source_mapping['start']:(v.source_mapping['start']+v.source_mapping['length'])] - (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(),old_str_of_interest.decode('utf-8'), 1) + old_str_of_interest = in_file_str[v.source_mapping['start']:(v.source_mapping['start']+ + v.source_mapping['length'])] + (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(), + old_str_of_interest.decode('utf-8'), 1) patch = { "file" : in_file, "detector" : "naming-convention (enum use)", @@ -535,17 +634,27 @@ class FormatNamingConvention: for ir in node.irs: if isinstance(ir, Member): if str(ir.variable_left) == name: - old_str_of_interest = in_file_str[node.source_mapping['start']:(node.source_mapping['start']+node.source_mapping['length'])].decode('utf-8').split('=')[1] + old_str_of_interest = in_file_str[node.source_mapping['start']: + (node.source_mapping['start']+ + node.source_mapping['length'])].decode('utf-8')\ + .split('=')[1] m = re.search(r'(.*)'+name, old_str_of_interest) old_str_of_interest = old_str_of_interest[m.span()[0]:] - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name, r'\1'+name[0].upper()+name[1:], old_str_of_interest, 1) + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name, r'\1'+name[0].upper()+name[1:], + old_str_of_interest, 1) if num_repl != 0: patch = { "file" : in_file, "detector" : "naming-convention (enum use)", - "start" : node.source_mapping['start'] + len(in_file_str[node.source_mapping['start']:(node.source_mapping['start']+node.source_mapping['length'])].decode('utf-8').split('=')[0]) + 1 + m.span()[0], - "end" : node.source_mapping['start'] + len(in_file_str[node.source_mapping['star\ -t']:(node.source_mapping['start']+node.source_mapping['length'])].decode('utf-8').split('=')[0]) + 1 + m.span()[0] + len(old_str_of_interest), + "start" : node.source_mapping['start'] + + len(in_file_str[node.source_mapping['start']: + (node.source_mapping['start']+ + node.source_mapping['length'])].decode('utf-8').split('=')[0]) + + 1 + m.span()[0], + "end" : node.source_mapping['start'] + + len(in_file_str[node.source_mapping['start']:(node.source_mapping['start']+ + node.source_mapping['length'])].\ + decode('utf-8').split('=')[0]) + 1 + m.span()[0] + len(old_str_of_interest), "old_string" : old_str_of_interest, "new_string" : new_str_of_interest } @@ -557,14 +666,17 @@ t']:(node.source_mapping['start']+node.source_mapping['length'])].decode('utf-8' # To-do: Check any other place/way where enum type is used @staticmethod - def create_patch_struct_definition(slither, patches, name, contract_name, in_file, in_file_relative, modify_loc_start, modify_loc_end): + def create_patch_struct_definition(slither, patches, name, contract_name, in_file, in_file_relative, modify_loc_start, + modify_loc_end): for contract in slither.contracts: if (contract.name == contract_name): for struct in contract.structures: if (struct.name == name): in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"struct"+r'(.*)'+name, r'\1'+"struct"+r'\2'+name[0].capitalize()+name[1:], old_str_of_interest.decode('utf-8'), 1) + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"struct"+r'(.*)'+name, r'\1'+"struct"+r'\2'+ + name[0].capitalize()+name[1:], + old_str_of_interest.decode('utf-8'), 1) if num_repl != 0: patch = { "file" : in_file, @@ -593,8 +705,10 @@ t']:(node.source_mapping['start']+node.source_mapping['length'])].decode('utf-8' svs = contract.variables for sv in svs: if (str(sv.type) == contract_name + "." + name): - old_str_of_interest = in_file_str[sv.source_mapping['start']:(sv.source_mapping['start']+sv.source_mapping['length'])] - (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(),old_str_of_interest.decode('utf-8'), 1) + old_str_of_interest = in_file_str[sv.source_mapping['start']:(sv.source_mapping['start']+ + sv.source_mapping['length'])] + (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(), + old_str_of_interest.decode('utf-8'), 1) patch = { "file" : in_file, "detector" : "naming-convention (struct use)", @@ -611,8 +725,10 @@ t']:(node.source_mapping['start']+node.source_mapping['length'])].decode('utf-8' for fm in fms: for v in fm.variables: if (str(v.type) == contract_name + "." + name): - old_str_of_interest = in_file_str[v.source_mapping['start']:(v.source_mapping['start']+v.source_mapping['length'])] - (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(),old_str_of_interest.decode('utf-8'), 1) + old_str_of_interest = in_file_str[v.source_mapping['start']:(v.source_mapping['start']+ + v.source_mapping['length'])] + (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(), + old_str_of_interest.decode('utf-8'), 1) patch = { "file" : in_file, "detector" : "naming-convention (struct use)", diff --git a/utils/slither_format/format_pragma.py b/utils/slither_format/format_pragma.py index 4f486e656..db4dce905 100644 --- a/utils/slither_format/format_pragma.py +++ b/utils/slither_format/format_pragma.py @@ -25,7 +25,10 @@ class FormatPragma: versions_used.append(''.join(element['type_specific_fields']['directive'][1:])) solc_version_replace = FormatPragma.analyse_versions(versions_used) for element in elements: - FormatPragma.create_patch(slither, patches, element['source_mapping']['filename_absolute'], element['source_mapping']['filename_relative'], solc_version_replace, element['source_mapping']['start'], element['source_mapping']['start'] + element['source_mapping']['length']) + FormatPragma.create_patch(slither, patches, element['source_mapping']['filename_absolute'], \ + element['source_mapping']['filename_relative'], solc_version_replace, \ + element['source_mapping']['start'], element['source_mapping']['start'] + \ + element['source_mapping']['length']) @staticmethod def analyse_versions(used_solc_versions): diff --git a/utils/slither_format/format_solc_version.py b/utils/slither_format/format_solc_version.py index 73bb5c323..6584020ee 100644 --- a/utils/slither_format/format_solc_version.py +++ b/utils/slither_format/format_solc_version.py @@ -21,8 +21,12 @@ class FormatSolcVersion: @staticmethod def format(slither, patches, elements): for element in elements: - solc_version_replace = FormatSolcVersion.determine_solc_version_replacement(''.join(element['type_specific_fields']['directive'][1:])) - FormatSolcVersion.create_patch(slither, patches, element['source_mapping']['filename_absolute'], element['source_mapping']['filename_relative'], solc_version_replace, element['source_mapping']['start'], element['source_mapping']['start'] + element['source_mapping']['length']) + solc_version_replace = FormatSolcVersion.determine_solc_version_replacement( + ''.join(element['type_specific_fields']['directive'][1:])) + FormatSolcVersion.create_patch(slither, patches, element['source_mapping']['filename_absolute'], \ + element['source_mapping']['filename_relative'], solc_version_replace, \ + element['source_mapping']['start'], element['source_mapping']['start'] + + element['source_mapping']['length']) @staticmethod def determine_solc_version_replacement(used_solc_version): diff --git a/utils/slither_format/format_unused_state.py b/utils/slither_format/format_unused_state.py index 1f8921b21..3fc40b19c 100644 --- a/utils/slither_format/format_unused_state.py +++ b/utils/slither_format/format_unused_state.py @@ -4,7 +4,9 @@ class FormatUnusedState: def format(slither, patches, elements): for element in elements: if element['type'] == "variable": - FormatUnusedState.create_patch(slither, patches, element['source_mapping']['filename_absolute'], element['source_mapping']['filename_relative'], element['source_mapping']['start']) + FormatUnusedState.create_patch(slither, patches, element['source_mapping']['filename_absolute'], \ + element['source_mapping']['filename_relative'], \ + element['source_mapping']['start']) @staticmethod def create_patch(slither, patches, in_file, in_file_relative, modify_loc_start): @@ -15,7 +17,8 @@ class FormatUnusedState: "detector" : "unused-state", "start" : modify_loc_start, "end" : modify_loc_start + len(old_str_of_interest.decode('utf-8').partition(';')[0]) + 1, - "old_string" : old_str_of_interest.decode('utf-8').partition(';')[0] + old_str_of_interest.decode('utf-8').partition(';')[1], + "old_string" : old_str_of_interest.decode('utf-8').partition(';')[0] + + old_str_of_interest.decode('utf-8').partition(';')[1], "new_string" : "" }) From eaf1c99ffec801619fc459de7806a99102a055c7 Mon Sep 17 00:00:00 2001 From: Josselin Date: Mon, 27 May 2019 10:05:47 +0100 Subject: [PATCH 039/223] Slither-format: - Fix setup.py - Use relative path to allow cli usage --- setup.py | 2 +- utils/slither_format/slither_format.py | 14 +++++++------- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/setup.py b/setup.py index c4c2e581a..66de10fdd 100644 --- a/setup.py +++ b/setup.py @@ -16,7 +16,7 @@ setup( 'slither = slither.__main__:main', 'slither-check-upgradeability = utils.upgradeability.__main__:main', 'slither-find-paths = utils.possible_paths.__main__:main', - 'slither-simil = utils.similarity.__main__:main' + 'slither-simil = utils.similarity.__main__:main', 'slither-format = utils.slither_format.__main__:main' ] } diff --git a/utils/slither_format/slither_format.py b/utils/slither_format/slither_format.py index 5a75d3a53..8838ba071 100644 --- a/utils/slither_format/slither_format.py +++ b/utils/slither_format/slither_format.py @@ -12,13 +12,13 @@ from slither.slithir.operations import InternalCall from slither.core.expressions.call_expression import CallExpression from slither.core.expressions.expression import Expression from slither.core.expressions.identifier import Identifier -from slither_format.format_unused_state import FormatUnusedState -from slither_format.format_solc_version import FormatSolcVersion -from slither_format.format_pragma import FormatPragma -from slither_format.format_naming_convention import FormatNamingConvention -from slither_format.format_external_function import FormatExternalFunction -from slither_format.format_constable_states import FormatConstableStates -from slither_format.format_constant_function import FormatConstantFunction +from .format_unused_state import FormatUnusedState +from .format_solc_version import FormatSolcVersion +from .format_pragma import FormatPragma +from .format_naming_convention import FormatNamingConvention +from .format_external_function import FormatExternalFunction +from .format_constable_states import FormatConstableStates +from .format_constant_function import FormatConstantFunction logging.basicConfig(level=logging.INFO) logger = logging.getLogger('Slither.Format') From dd631a1a089f9602d839c181364f3bdb94e3ac3a Mon Sep 17 00:00:00 2001 From: rajeevgopalakrishna Date: Tue, 28 May 2019 13:29:20 +0530 Subject: [PATCH 040/223] - Fixes contract naming convention to include interface & library - Adds success info messages - Adds runSlitherFormat script to run slither-format on a directory of files --- .../format_naming_convention.py | 16 +++++++++++-- utils/slither_format/slither_format.py | 3 +++ .../slither_format/tests/runSlitherFormat.py | 24 +++++++++++++++++++ 3 files changed, 41 insertions(+), 2 deletions(-) create mode 100644 utils/slither_format/tests/runSlitherFormat.py diff --git a/utils/slither_format/format_naming_convention.py b/utils/slither_format/format_naming_convention.py index 2a902a314..740530a6c 100644 --- a/utils/slither_format/format_naming_convention.py +++ b/utils/slither_format/format_naming_convention.py @@ -94,9 +94,9 @@ class FormatNamingConvention: def create_patch_contract_definition(slither, patches, name, in_file, in_file_relative, modify_loc_start, modify_loc_end): in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - m = re.match(r'(.*)'+"contract"+r'(.*)'+name, old_str_of_interest.decode('utf-8')) + m = re.match(r'(.*)'+"(contract|interface|library)"+r'(.*)'+name, old_str_of_interest.decode('utf-8')) old_str_of_interest = in_file_str[modify_loc_start:modify_loc_start+m.span()[1]] - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"contract"+r'(.*)'+name, r'\1'+"contract"+r'\2'+name.capitalize(), + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+r'(contract|interface|library)'+r'(.*)'+name, r'\1'+r'\2'+r'\3'+name.capitalize(), old_str_of_interest.decode('utf-8'), 1) if num_repl != 0: patch = { @@ -166,6 +166,9 @@ class FormatNamingConvention: old_str_of_interest = in_file_str[node.source_mapping['start']:node.source_mapping['start'] + node.source_mapping['length']] m = re.search("new"+r'(.*)'+name, old_str_of_interest.decode('utf-8')) + # Skip rare cases where re search fails. To-do: Investigate + if not m: + continue old_str_of_interest = old_str_of_interest.decode('utf-8')[m.span()[0]:] (new_str_of_interest, num_repl) = re.subn("new"+r'(.*)'+name, "new"+r'\1'+name[0].upper() + name[1:], old_str_of_interest, 1) @@ -430,6 +433,9 @@ class FormatNamingConvention: (node._local_vars_read + node._local_vars_written) if str(lv) == name]: + # Skip rare cases where source_mapping is absent. To-do: Investigate + if not v.source_mapping: + continue modify_loc_start = int(v.source_mapping['start']) modify_loc_end = int(v.source_mapping['start']) + int(v.source_mapping['length']) old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] @@ -500,6 +506,9 @@ class FormatNamingConvention: in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] m = re.search(name, old_str_of_interest.decode('utf-8')) + # Skip rare cases where re search fails. To-do: Investigate + if not m: + continue if (_target == "variable_constant"): new_string = old_str_of_interest.decode('utf-8')[m.span()[0]:m.span()[1]].upper() else: @@ -639,6 +648,9 @@ class FormatNamingConvention: node.source_mapping['length'])].decode('utf-8')\ .split('=')[1] m = re.search(r'(.*)'+name, old_str_of_interest) + # Skip rare cases where re search fails. To-do: Investigate + if not m: + continue old_str_of_interest = old_str_of_interest[m.span()[0]:] (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name, r'\1'+name[0].upper()+name[1:], old_str_of_interest, 1) diff --git a/utils/slither_format/slither_format.py b/utils/slither_format/slither_format.py index 8838ba071..5bc3f5596 100644 --- a/utils/slither_format/slither_format.py +++ b/utils/slither_format/slither_format.py @@ -106,11 +106,14 @@ def generate_patch_files(slither, patches): out_file = open(_in_file+".format",'w') out_file.write(out_file_str) out_file.close() + logger.info("slither-format successful.") + logger.info("Created formatted file: " + _in_file+".format") patch_file_name = _in_file + ".format.patch" outFD = open(patch_file_name,"w") p1 = subprocess.Popen(['diff', '-u', _in_file, _in_file+".format"], stdout=outFD) p1.wait() outFD.close() + logger.info("Created patch file: " + patch_file_name) def print_patches(number_of_slither_results, patches): logger.info("Number of Slither results: " + str(number_of_slither_results)) diff --git a/utils/slither_format/tests/runSlitherFormat.py b/utils/slither_format/tests/runSlitherFormat.py new file mode 100644 index 000000000..4f0efd84c --- /dev/null +++ b/utils/slither_format/tests/runSlitherFormat.py @@ -0,0 +1,24 @@ +from os import listdir +from os.path import isfile, join +import subprocess + +contracts_path = "../../smart-contracts-detectors-testing/most_used/contracts/" +slither_format_output_path = "./slither_format/tests/slither_format_output_most_used_contracts/" + +def analyze_contract_with_slither_format(): + for contract_file in contract_files: + run_slither_format(contract_file) + +def run_slither_format(contract_name): + print("Running Slither Format on contract: " + contract_name) + command = "python3 -m slither_format " + contracts_path+contract_name + contract_slither_output_fd = open(slither_format_output_path+contract_name[:-21]+".txt","w+") + contract_slither_output_fd.write("Command run: " + command + "\n\n") + contract_slither_output_fd.flush() + result = subprocess.run(command, shell=True, stdout=contract_slither_output_fd, stderr=contract_slither_output_fd) + contract_slither_output_fd.close() + +if __name__ == "__main__": + contract_files = [f for f in listdir(contracts_path) if f.endswith(".sol")] + print("Number of contract files: " + str(len(contract_files))) + analyze_contract_with_slither_format() From 09e32f16768084a7b5e7ee1262d239be404bb72a Mon Sep 17 00:00:00 2001 From: rajeevgopalakrishna Date: Tue, 28 May 2019 16:17:49 +0530 Subject: [PATCH 041/223] slither-format: - Updated README - Added comments --- utils/slither_format/README.md | 10 +++++++++- utils/slither_format/__main__.py | 1 + utils/slither_format/slither_format.py | 15 +++++++++++++-- 3 files changed, 23 insertions(+), 3 deletions(-) diff --git a/utils/slither_format/README.md b/utils/slither_format/README.md index c3f291655..42469f42a 100644 --- a/utils/slither_format/README.md +++ b/utils/slither_format/README.md @@ -30,9 +30,15 @@ Slither detectors highlight names, context and source-mapping of code constructs Run Slither-format on a single file: ``` $ python3 -m slither-format ./utils/slither_format/tests/test_data/constant.sol +``` + +or + +``` +$ slither-format ./utils/slither_format/tests/test_data/constant.sol ``` -This produces `constant.sol.format` file which has all the feature replacements. +This produces a `constant.sol.format` file which has all the feature replacements. It also produces a `constant.sol.format.patch` file which is a `git` compatible patch file that can be used to apply format diffs to the original file. ## Dependencies @@ -53,5 +59,7 @@ $ python3 ./slither_format/tests/test_constant_function.py $ python3 ./slither_format/tests/test_solc_version.py $ python3 ./slither_format/tests/test_pragma.py $ python3 ./slither_format/tests/test_naming_convention.py +$ python3 ./slither_format/tests/test_detector_combinations.py $ python3 ./slither_format/tests/run_all_tests.py +$ python3 ./slither_format/tests/runSlitherFormat.py ``` diff --git a/utils/slither_format/__main__.py b/utils/slither_format/__main__.py index feaf39ac8..7f23ca268 100644 --- a/utils/slither_format/__main__.py +++ b/utils/slither_format/__main__.py @@ -9,6 +9,7 @@ from crytic_compile import cryticparser logging.basicConfig() logging.getLogger("Slither").setLevel(logging.INFO) +# Slither detectors for which slither-format currently works available_detectors = ["unused-state", "solc-version", "pragma", diff --git a/utils/slither_format/slither_format.py b/utils/slither_format/slither_format.py index 5bc3f5596..af913d58e 100644 --- a/utils/slither_format/slither_format.py +++ b/utils/slither_format/slither_format.py @@ -45,13 +45,21 @@ def slither_format(args, slither): 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 slither detector results on contract files to generate patches apply_detector_results(slither, patches, detector_results) + # Sort the patches in ascending order of the source mapping i.e. from beginning of contract file to end. + # Multiple detectors can produce alerts on same code fragments e.g. unused-state and constable-states. + # The current approach makes a single pass on the contract file to apply patches. + # Therefore, overlapping patches are ignored for now. Neither is applied. + # To-do: Prioritise one detector over another (via user input or hardcoded) for overlapping patches. sort_and_flag_overlapping_patches(patches) + # Remove overlapping 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) + print_patches(number_of_slither_results, patches) + # Generate git-compatible patch files generate_patch_files(slither, patches) def sort_and_flag_overlapping_patches(patches): @@ -175,6 +183,9 @@ def choose_detectors(args): return detectors_to_run def apply_detector_results(slither, patches, detector_results): + ''' + Apply slither detector results on contract files to generate patches + ''' for result in detector_results: if result['check'] == 'unused-state': FormatUnusedState.format(slither, patches, result['elements']) @@ -191,7 +202,7 @@ def apply_detector_results(slither, patches, detector_results): elif result['check'] == 'constant-function': FormatConstantFunction.format(slither, patches, result['elements']) else: - logger.error(red("Not Supported Yet.")) + logger.error(red(result['check'] + "detector not supported yet.")) sys.exit(-1) def get_number_of_slither_results (detector_results): From c8c7c7c799a384bec15990aa9c891068d12fcbb7 Mon Sep 17 00:00:00 2001 From: rajeevgopalakrishna Date: Tue, 28 May 2019 20:58:21 +0530 Subject: [PATCH 042/223] slither-format: - Added comments on regex and string manipulations - Changed upper() to capitalize() in few places --- .../slither_format/format_constable_states.py | 1 + .../format_constant_function.py | 5 +- .../format_external_function.py | 13 +++- .../format_naming_convention.py | 72 +++++++++++++++---- utils/slither_format/format_pragma.py | 2 + utils/slither_format/format_solc_version.py | 4 ++ utils/slither_format/format_unused_state.py | 1 + 7 files changed, 80 insertions(+), 18 deletions(-) diff --git a/utils/slither_format/format_constable_states.py b/utils/slither_format/format_constable_states.py index ca0cf9cb2..f59a471fa 100644 --- a/utils/slither_format/format_constable_states.py +++ b/utils/slither_format/format_constable_states.py @@ -19,6 +19,7 @@ class FormatConstableStates: def create_patch(slither, patches, in_file, in_file_relative, match_text, replace_text, modify_loc_start, modify_loc_end): in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + # Add keyword `constant` before the variable name (new_str_of_interest, num_repl) = re.subn(match_text, replace_text, old_str_of_interest.decode('utf-8'), 1) if num_repl != 0: patches[in_file_relative].append({ diff --git a/utils/slither_format/format_constant_function.py b/utils/slither_format/format_constant_function.py index 936216f2b..8dc8c452b 100644 --- a/utils/slither_format/format_constant_function.py +++ b/utils/slither_format/format_constant_function.py @@ -29,6 +29,7 @@ class FormatConstantFunction: def create_patch(slither, patches, in_file, in_file_relative, match_text, replace_text, modify_loc_start, modify_loc_end): in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + # Find the keywords view|pure|constant and remove them m = re.search("(view|pure|constant)", old_str_of_interest.decode('utf-8')) if m: patches[in_file_relative].append({ @@ -36,8 +37,8 @@ class FormatConstantFunction: "detector" : "constant-function", "start" : modify_loc_start + m.span()[0], "end" : modify_loc_start + m.span()[1], - "old_string" : m.groups(0)[0], - "new_string" : replace_text + "old_string" : m.groups(0)[0], # this is view|pure|constant + "new_string" : replace_text # this is an empty string "" }) else: logger.error(red("No view/pure/constant specifier exists. Regex failed to remove specifier!")) diff --git a/utils/slither_format/format_external_function.py b/utils/slither_format/format_external_function.py index 21d4bce27..2776e7e75 100644 --- a/utils/slither_format/format_external_function.py +++ b/utils/slither_format/format_external_function.py @@ -17,6 +17,7 @@ class FormatExternalFunction: # If function parameters are written to in function body then we cannot convert this function # to external because external function parameters are allocated in calldata region which is # non-modifiable. See https://solidity.readthedocs.io/en/develop/types.html#data-location + # Remove this once PR #257 is merged if not FormatExternalFunction.function_parameters_written(function): FormatExternalFunction.create_patch(slither, patches, \ element['source_mapping']['filename_absolute'], \ @@ -30,25 +31,31 @@ class FormatExternalFunction: def create_patch(slither, patches, in_file, in_file_relative, match_text, replace_text, modify_loc_start, modify_loc_end): in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + # Search for 'public' keyword which is in-between the function name and modifier name (if present) + # regex: 'public' could have spaces around or be at the end of the line m = re.search(r'((\spublic)\s+)|(\spublic)$|(\)public)$', old_str_of_interest.decode('utf-8')) if m is None: # No visibility specifier exists; public by default. patches[in_file_relative].append({ "file" : in_file, "detector" : "external-function", + # start after the function definition's closing paranthesis "start" : modify_loc_start + len(old_str_of_interest.decode('utf-8').split(')')[0]) + 1, + # end is same as start because we insert the keyword `external` at that location "end" : modify_loc_start + len(old_str_of_interest.decode('utf-8').split(')')[0]) + 1, "old_string" : "", - "new_string" : " " + replace_text + "new_string" : " " + replace_text # replace_text is `external` }) else: patches[in_file_relative].append({ "file" : in_file, "detector" : "external-function", + # start at the keyword `public` "start" : modify_loc_start + m.span()[0] + 1, + # end after the keyword `public` = start + len('public'') "end" : modify_loc_start + m.span()[0] + 1 + 6, - "old_string" : match_text, - "new_string" : replace_text + "old_string" : match_text, # match_text is `public` + "new_string" : replace_text # replace_text is `external` }) @staticmethod diff --git a/utils/slither_format/format_naming_convention.py b/utils/slither_format/format_naming_convention.py index 740530a6c..5bcb6fded 100644 --- a/utils/slither_format/format_naming_convention.py +++ b/utils/slither_format/format_naming_convention.py @@ -94,9 +94,12 @@ class FormatNamingConvention: def create_patch_contract_definition(slither, patches, name, in_file, in_file_relative, modify_loc_start, modify_loc_end): in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + # Locate the name following keywords `contract` | `interface` | `library` m = re.match(r'(.*)'+"(contract|interface|library)"+r'(.*)'+name, old_str_of_interest.decode('utf-8')) old_str_of_interest = in_file_str[modify_loc_start:modify_loc_start+m.span()[1]] - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+r'(contract|interface|library)'+r'(.*)'+name, r'\1'+r'\2'+r'\3'+name.capitalize(), + # Capitalize the name + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+r'(contract|interface|library)'+r'(.*)'+name, + r'\1'+r'\2'+r'\3'+name.capitalize(), old_str_of_interest.decode('utf-8'), 1) if num_repl != 0: patch = { @@ -146,6 +149,7 @@ class FormatNamingConvention: if (str(v.type) == name): old_str_of_interest = in_file_str[v.source_mapping['start']:(v.source_mapping['start'] + v.source_mapping['length'])] + # Get only the contract variable name even if it is initialised old_str_of_interest = old_str_of_interest.decode('utf-8').split('=')[0] (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(),old_str_of_interest, 1) patch = { @@ -165,17 +169,19 @@ class FormatNamingConvention: if isinstance(ir, NewContract) and ir.contract_name == name: old_str_of_interest = in_file_str[node.source_mapping['start']:node.source_mapping['start'] + node.source_mapping['length']] + # Search for the name after the `new` keyword m = re.search("new"+r'(.*)'+name, old_str_of_interest.decode('utf-8')) # Skip rare cases where re search fails. To-do: Investigate if not m: continue old_str_of_interest = old_str_of_interest.decode('utf-8')[m.span()[0]:] - (new_str_of_interest, num_repl) = re.subn("new"+r'(.*)'+name, "new"+r'\1'+name[0].upper() + - name[1:], old_str_of_interest, 1) + (new_str_of_interest, num_repl) = re.subn("new"+r'(.*)'+name, "new"+r'\1'+name.capitalize(), + old_str_of_interest, 1) if num_repl != 0: patch = { "file" : in_file, "detector" : "naming-convention (contract new object)", + # start after the `new` keyword where the name begins "start" : node.source_mapping['start'] + m.span()[0], "end" : node.source_mapping['start'] + m.span()[1], "old_string" : old_str_of_interest, @@ -198,8 +204,10 @@ class FormatNamingConvention: if modifier.name == name: in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + # Search for the modifier name after the `modifier` keyword m = re.match(r'(.*)'+"modifier"+r'(.*)'+name, old_str_of_interest.decode('utf-8')) old_str_of_interest = in_file_str[modify_loc_start:modify_loc_start+m.span()[1]] + # Change the first letter of the modifier name to lowercase (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"modifier"+r'(.*)'+name, r'\1'+"modifier"+r'\2' + name[0].lower()+name[1:], old_str_of_interest.decode('utf-8'), 1) if num_repl != 0: @@ -228,8 +236,12 @@ class FormatNamingConvention: for m in function.modifiers: if (m.name == name): in_file_str = slither.source_code[in_file].encode('utf-8') + # Get the text from function parameters until the return statement or function body beginning + # This text will include parameter declarations, any Solidity keywords and modifier call + # Parameter names cannot collide with modifier name per Solidity rules old_str_of_interest = in_file_str[int(function.parameters_src.source_mapping['start']): int(function.returns_src.source_mapping['start'])] + # Change the first letter of the modifier name (if present) to lowercase (new_str_of_interest, num_repl) = re.subn(name, name[0].lower()+name[1:], old_str_of_interest.decode('utf-8'),1) if num_repl != 0: @@ -258,8 +270,10 @@ class FormatNamingConvention: if function.name == name: in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + # Search for the function name after the `function` keyword m = re.match(r'(.*)'+"function"+r'\s*'+name, old_str_of_interest.decode('utf-8')) old_str_of_interest = in_file_str[modify_loc_start:modify_loc_start+m.span()[1]] + # Change the first letter of the function name to lowercase (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"function"+r'(.*)'+name, r'\1'+"function"+r'\2'+ name[0].lower()+name[1:], old_str_of_interest.decode('utf-8'), 1) if num_repl != 0: @@ -282,17 +296,22 @@ class FormatNamingConvention: for contract in slither.contracts: for function in contract.functions: for node in function.nodes: + # Function call from another contract for high_level_call in node.high_level_calls: if (high_level_call[0].name == contract_name and high_level_call[1].name == name): for external_call in node.external_calls_as_expressions: + # Check the called function name called_function = str(external_call.called).split('.')[-1] if called_function == high_level_call[1].name: in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[int(external_call.source_mapping['start']): int(external_call.source_mapping['start']) + int(external_call.source_mapping['length'])] + # Get the called function name. To-do: Check if we need to avoid parameters called_function_name = old_str_of_interest.decode('utf-8').split('.')[-1] + # Convert first letter of name to lowercase fixed_function_name = called_function_name[0].lower() + called_function_name[1:] + # Reconstruct the entire call new_string = '.'.join(old_str_of_interest.decode('utf-8').split('.')[:-1]) + '.' + \ fixed_function_name patch = { @@ -306,17 +325,20 @@ class FormatNamingConvention: } if not patch in patches[in_file_relative]: patches[in_file_relative].append(patch) + # Function call from within same contract for internal_call in node.internal_calls_as_expressions: if (str(internal_call.called) == name): in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[int(internal_call.source_mapping['start']): int(internal_call.source_mapping['start']) + int(internal_call.source_mapping['length'])] + # Get the called function name and avoid parameters old_str_of_interest = old_str_of_interest.decode('utf-8').split('(')[0] patch = { "file" : in_file, "detector" : "naming-convention (function calls)", "start" : internal_call.source_mapping['start'], + # Avoid parameters "end" : int(internal_call.source_mapping['start']) + int(internal_call.source_mapping['length']) - len('('.join(in_file_str[int(internal_call.source_mapping['start']): @@ -338,11 +360,13 @@ class FormatNamingConvention: sys.exit(-1) for event in target_contract.events: if event.name == name: + # Get only event name without parameters event_name = name.split('(')[0] in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + # Capitalize event name (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"event"+r'(.*)'+event_name, r'\1'+"event"+r'\2' + - event_name[0].capitalize()+event_name[1:], + event_name.capitalize(), old_str_of_interest.decode('utf-8'), 1) if num_repl != 0: patch = { @@ -361,6 +385,7 @@ class FormatNamingConvention: @staticmethod def create_patch_event_calls(slither, patches, name, contract_name, in_file, in_file_relative): + # Get only event name without parameters event_name = name.split('(')[0] target_contract = slither.get_contract_from_name(contract_name) if not target_contract: @@ -381,8 +406,8 @@ class FormatNamingConvention: "start" : call.source_mapping['start'], "end" : int(call.source_mapping['start']) + int(call.source_mapping['length']), "old_string" : old_str_of_interest.decode('utf-8'), - "new_string" : old_str_of_interest.decode('utf-8')[0].capitalize() + - old_str_of_interest.decode('utf-8')[1:] + # Capitalize event name + "new_string" : old_str_of_interest.decode('utf-8').capitalize() } if not patch in patches[in_file_relative]: patches[in_file_relative].append(patch) @@ -398,12 +423,15 @@ class FormatNamingConvention: if function.name == function_name: in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + # To-do: Change format logic below - how do we convert a name to mixedCase? if(name[0] == '_'): + # If parameter name begins with underscore, capitalize the letter after underscore (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+name[0]+name[1].upper() + name[2:]+r'\2', old_str_of_interest.decode('utf-8'), 1) else: - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+'_'+name[0].upper() + - name[1:]+r'\2', old_str_of_interest.decode('utf-8'), 1) + # Add underscore and capitalize the first letter + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+'_'+name.capitalize() + + r'\2', old_str_of_interest.decode('utf-8'), 1) if num_repl != 0: patch = { "file" : in_file, @@ -439,14 +467,17 @@ class FormatNamingConvention: modify_loc_start = int(v.source_mapping['start']) modify_loc_end = int(v.source_mapping['start']) + int(v.source_mapping['length']) old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + # To-do: Change format logic below - how do we convert a name to mixedCase? if(name[0] == '_'): + # If parameter name begins with underscore, capitalize the letter after underscore (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+name[0]+name[1].upper()+name[2:] + r'\2', old_str_of_interest.decode('utf-8'), 1) else: + # Add underscore and capitalize the first letter (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+'_' + - name[0].upper()+name[1:]+r'\2', + name.capitalize()+r'\2', old_str_of_interest.decode('utf-8'), 1) if num_repl != 0: patch = { @@ -470,20 +501,25 @@ class FormatNamingConvention: old_str_of_interest = in_file_str[modifier.source_mapping['start']: modifier.source_mapping['start'] + modifier.source_mapping['length']] + # Get text beyond modifier name which contains parameters old_str_of_interest_beyond_modifier_name = old_str_of_interest.decode('utf-8')\ .split('(')[1] + # To-do: Change format logic below - how do we convert a name to mixedCase? if(name[0] == '_'): + # If parameter name begins with underscore, capitalize the letter after underscore (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+name[0]+ name[1].upper()+name[2:]+r'\2', old_str_of_interest_beyond_modifier_name, 1) else: + # Add underscore and capitalize the first letter (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+'_'+ - name[0].upper()+name[1:]+r'\2', + name.capitalize()+r'\2', old_str_of_interest_beyond_modifier_name, 1) if num_repl != 0: patch = { "file" : in_file, "detector" : "naming-convention (parameter uses)", + # Start beyond modifier name which contains parameters "start" : modifier.source_mapping['start'] + len(old_str_of_interest.decode('utf-8').split('(')[0]) + 1, "end" : modifier.source_mapping['start'] + modifier.source_mapping['length'], @@ -505,11 +541,13 @@ class FormatNamingConvention: if (var.name == name): in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + # Search for the state variable name and avoid the type m = re.search(name, old_str_of_interest.decode('utf-8')) # Skip rare cases where re search fails. To-do: Investigate if not m: continue if (_target == "variable_constant"): + # Convert constant state variables to upper case new_string = old_str_of_interest.decode('utf-8')[m.span()[0]:m.span()[1]].upper() else: new_string = old_str_of_interest.decode('utf-8')[m.span()[0]:m.span()[1]] @@ -517,6 +555,7 @@ class FormatNamingConvention: patch = { "file" : in_file, "detector" : "naming-convention (state variable declaration)", + # Target only the state variable name and avoid the type "start" : modify_loc_start+m.span()[0], "end" : modify_loc_start+m.span()[1], "old_string" : old_str_of_interest.decode('utf-8')[m.span()[0]:m.span()[1]], @@ -547,6 +586,7 @@ class FormatNamingConvention: in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] if (_target == "variable_constant"): + # Convert constant state variables to upper case new_str_of_interest = old_str_of_interest.decode('utf-8').upper() else: new_str_of_interest = old_str_of_interest.decode('utf-8') @@ -571,8 +611,10 @@ class FormatNamingConvention: if (enum.name == name): in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + # Search for the enum name after the `enum` keyword + # Capitalize enum name (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"enum"+r'(.*)'+name, r'\1'+"enum"+r'\2'+ - name[0].capitalize()+name[1:], + name.capitalize(), old_str_of_interest.decode('utf-8'), 1) if num_repl != 0: patch = { @@ -643,6 +685,7 @@ class FormatNamingConvention: for ir in node.irs: if isinstance(ir, Member): if str(ir.variable_left) == name: + # Skip past the assignment old_str_of_interest = in_file_str[node.source_mapping['start']: (node.source_mapping['start']+ node.source_mapping['length'])].decode('utf-8')\ @@ -652,17 +695,19 @@ class FormatNamingConvention: if not m: continue old_str_of_interest = old_str_of_interest[m.span()[0]:] - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name, r'\1'+name[0].upper()+name[1:], + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name, r'\1'+name.capitalize(), old_str_of_interest, 1) if num_repl != 0: patch = { "file" : in_file, "detector" : "naming-convention (enum use)", + # Start past the assignment "start" : node.source_mapping['start'] + len(in_file_str[node.source_mapping['start']: (node.source_mapping['start']+ node.source_mapping['length'])].decode('utf-8').split('=')[0]) + 1 + m.span()[0], + # End accounts for the assignment from the start "end" : node.source_mapping['start'] + len(in_file_str[node.source_mapping['start']:(node.source_mapping['start']+ node.source_mapping['length'])].\ @@ -686,8 +731,9 @@ class FormatNamingConvention: if (struct.name == name): in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + # Capitalize the struct name beyond the keyword `struct` (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"struct"+r'(.*)'+name, r'\1'+"struct"+r'\2'+ - name[0].capitalize()+name[1:], + name.capitalize(), old_str_of_interest.decode('utf-8'), 1) if num_repl != 0: patch = { diff --git a/utils/slither_format/format_pragma.py b/utils/slither_format/format_pragma.py index db4dce905..5954657a6 100644 --- a/utils/slither_format/format_pragma.py +++ b/utils/slither_format/format_pragma.py @@ -60,8 +60,10 @@ class FormatPragma: minor_version_left = '.'.join(version_left[2:])[2] minor_version_right = '.'.join(version_right[2:])[2] if minor_version_right == '4': + # Replace with 0.4.25 return "pragma solidity " + FormatPragma.REPLACEMENT_VERSIONS[0] + ';' elif minor_version_right in ['5','6']: + # Replace with 0.5.3 return "pragma solidity " + FormatPragma.REPLACEMENT_VERSIONS[1] + ';' @staticmethod diff --git a/utils/slither_format/format_solc_version.py b/utils/slither_format/format_solc_version.py index 6584020ee..150e084bc 100644 --- a/utils/slither_format/format_solc_version.py +++ b/utils/slither_format/format_solc_version.py @@ -35,8 +35,10 @@ class FormatSolcVersion: version = versions[0] minor_version = '.'.join(version[2:])[2] if minor_version == '4': + # Replace with 0.4.25 return "pragma solidity " + FormatSolcVersion.REPLACEMENT_VERSIONS[0] + ';' elif minor_version == '5': + # Replace with 0.5.3 return "pragma solidity " + FormatSolcVersion.REPLACEMENT_VERSIONS[1] + ';' else: logger.error(red("Unknown version!")) @@ -47,8 +49,10 @@ class FormatSolcVersion: minor_version_left = '.'.join(version_left[2:])[2] minor_version_right = '.'.join(version_right[2:])[2] if minor_version_right == '4': + # Replace with 0.4.25 return "pragma solidity " + FormatSolcVersion.REPLACEMENT_VERSIONS[0] + ';' elif minor_version_right in ['5','6']: + # Replace with 0.5.3 return "pragma solidity " + FormatSolcVersion.REPLACEMENT_VERSIONS[1] + ';' @staticmethod diff --git a/utils/slither_format/format_unused_state.py b/utils/slither_format/format_unused_state.py index 3fc40b19c..e4f7f5fde 100644 --- a/utils/slither_format/format_unused_state.py +++ b/utils/slither_format/format_unused_state.py @@ -16,6 +16,7 @@ class FormatUnusedState: "file" : in_file, "detector" : "unused-state", "start" : modify_loc_start, + # Remove the entire declaration until the semicolon "end" : modify_loc_start + len(old_str_of_interest.decode('utf-8').partition(';')[0]) + 1, "old_string" : old_str_of_interest.decode('utf-8').partition(';')[0] + old_str_of_interest.decode('utf-8').partition(';')[1], From 4efe4b2fb573522b63e069ce34633acbe1e5ed65 Mon Sep 17 00:00:00 2001 From: David Pokora Date: Tue, 28 May 2019 21:17:59 -0400 Subject: [PATCH 043/223] -stdout/stderr redirect to capture output and output in JSON results -JSON result output cleanup --- slither/__main__.py | 80 ++++++++++++++------------------ slither/utils/output_redirect.py | 67 ++++++++++++++++++++++++++ 2 files changed, 103 insertions(+), 44 deletions(-) create mode 100644 slither/utils/output_redirect.py diff --git a/slither/__main__.py b/slither/__main__.py index 5a0563fa3..38b5c25ef 100644 --- a/slither/__main__.py +++ b/slither/__main__.py @@ -19,6 +19,7 @@ from slither.detectors.abstract_detector import (AbstractDetector, from slither.printers import all_printers from slither.printers.abstract_printer import AbstractPrinter from slither.slither import Slither +from slither.utils.output_redirect import StandardOutputRedirect from slither.utils.colors import red, yellow, set_colorization_enabled from slither.utils.command_line import (output_detectors, output_results_to_markdown, output_detectors_json, output_printers, @@ -100,27 +101,16 @@ def process_files(filenames, args, detector_classes, printer_classes): ################################################################################### -def wrap_json_detectors_results(success, error_message, results=None): - """ - Wrap the detector results. - :param success: - :param error_message: - :param results: - :return: - """ - results_json = {} - if results: - results_json['detectors'] = results - return { - "success": success, - "error": error_message, - "results": results_json +def output_json(filename, error, results): + # Create our encapsulated JSON result. + json_result = { + "success": error is None, + "error": error, + "results": results } - -def output_json(results, filename): - json_result = wrap_json_detectors_results(True, None, results) - if filename is None: + # Determine if our filename is referring to stdout + if filename == "-": # Write json to console print(json.dumps(json_result)) else: @@ -350,13 +340,11 @@ def parse_args(detector_classes, printer_classes): action='store_true', default=defaults_flag_in_config['exclude_high']) - group_misc.add_argument('--json', help='Export the results as a JSON file ("--json -" to export to stdout)', action='store', default=defaults_flag_in_config['json']) - group_misc.add_argument('--disable-color', help='Disable output colorization', action='store_true', @@ -396,7 +384,6 @@ def parse_args(detector_classes, printer_classes): action=OutputMarkdown, default=False) - group_misc.add_argument('--checklist', help=argparse.SUPPRESS, action='store_true', @@ -524,10 +511,12 @@ def main_impl(all_detector_classes, all_printer_classes): # Set colorization option set_colorization_enabled(not args.disable_color) - # If we are outputting json to stdout, we'll want to disable any logging. - stdout_json = args.json == "-" - if stdout_json: - logging.disable(logging.CRITICAL) + # If we are outputting json to stdout, we'll want to define some variables and redirect stdout + output_error = None + json_results = {} + outputting_json = args.json is not None + if outputting_json: + StandardOutputRedirect.enable() printer_classes = choose_printers(args, all_printer_classes) detector_classes = choose_detectors(args, all_detector_classes) @@ -586,8 +575,8 @@ def main_impl(all_detector_classes, all_printer_classes): else: raise Exception("Unrecognised file/dir path: '#{filename}'".format(filename=filename)) - if args.json: - output_json(results, None if stdout_json else args.json) + if args.json and results: + json_results['detectors'] = results if args.checklist: output_results_to_markdown(results) # Dont print the number of result for printers @@ -599,27 +588,30 @@ def main_impl(all_detector_classes, all_printer_classes): logger.info('%s analyzed (%d contracts), %d result(s) found', filename, number_contracts, len(results)) if args.ignore_return_value: return - exit(results) except SlitherException as se: - # Output our error accordingly, via JSON or logging. - if stdout_json: - print(json.dumps(wrap_json_detectors_results(False, str(se), []))) - else: - logging.error(red('Error:')) - logging.error(red(se)) - logging.error('Please report an issue to https://github.com/crytic/slither/issues') - sys.exit(-1) + output_error = str(se) + logging.error(red('Error:')) + logging.error(red(output_error)) + logging.error('Please report an issue to https://github.com/crytic/slither/issues') except Exception: - # Output our error accordingly, via JSON or logging. - if stdout_json: - print(json.dumps(wrap_json_detectors_results(False, traceback.format_exc(), []))) - else: - logging.error('Error in %s' % args.filename) - logging.error(traceback.format_exc()) + output_error = traceback.format_exc() + logging.error('Error in %s' % args.filename) + logging.error(output_error) + + # If we are outputting JSON, capture the redirected output and disable the redirect to output the final JSON. + if outputting_json: + json_results['stdout'] = StandardOutputRedirect.get_stdout_output() + json_results['stderr'] = StandardOutputRedirect.get_stderr_output() + StandardOutputRedirect.disable() + output_json(args.json, output_error, json_results) + + # Exit with the appropriate status code + if output_error: sys.exit(-1) - + else: + exit(results) if __name__ == '__main__': diff --git a/slither/utils/output_redirect.py b/slither/utils/output_redirect.py new file mode 100644 index 000000000..9811b21b2 --- /dev/null +++ b/slither/utils/output_redirect.py @@ -0,0 +1,67 @@ +import io +import logging +import sys + + +class StandardOutputRedirect: + """ + Redirects and captures standard output/errors. + """ + original_stdout = None + original_stderr = None + + @staticmethod + def enable(): + """ + Redirects stdout and/or stderr to a captureable StringIO. + :param redirect_stdout: True if redirection is desired for stdout. + :param redirect_stderr: True if redirection is desired for stderr. + :return: None + """ + # Redirect stdout + if StandardOutputRedirect.original_stdout is None: + StandardOutputRedirect.original_stdout = sys.stdout + sys.stdout = io.StringIO() + + # Redirect stderr + if StandardOutputRedirect.original_stderr is None: + StandardOutputRedirect.original_stderr = sys.stderr + sys.stderr = io.StringIO() + root_logger = logging.getLogger() + root_logger.handlers = [logging.StreamHandler(sys.stderr)] + + @staticmethod + def disable(): + """ + Disables redirection of stdout/stderr, if previously enabled. + :return: None + """ + # If we have a stdout backup, restore it. + if StandardOutputRedirect.original_stdout is not None: + sys.stdout.close() + sys.stdout = StandardOutputRedirect.original_stdout + StandardOutputRedirect.original_stdout = None + + # If we have an stderr backup, restore it. + if StandardOutputRedirect.original_stderr is not None: + sys.stderr.close() + sys.stderr = StandardOutputRedirect.original_stderr + StandardOutputRedirect.original_stderr = None + + @staticmethod + def get_stdout_output(): + """ + Obtains the output from stdout + :return: Returns stdout output as a string + """ + sys.stdout.seek(0) + return sys.stdout.read() + + @staticmethod + def get_stderr_output(): + """ + Obtains the output from stdout + :return: Returns stdout output as a string + """ + sys.stderr.seek(0) + return sys.stderr.read() \ No newline at end of file From 5f7e38869a3c2beb5aebe315d5ecd07a8db43258 Mon Sep 17 00:00:00 2001 From: rajeevgopalakrishna Date: Wed, 29 May 2019 08:36:37 +0530 Subject: [PATCH 044/223] Updated README's To-do list of known limitations. --- utils/slither_format/README.md | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/utils/slither_format/README.md b/utils/slither_format/README.md index 42469f42a..91fda1b43 100644 --- a/utils/slither_format/README.md +++ b/utils/slither_format/README.md @@ -44,10 +44,12 @@ This produces a `constant.sol.format` file which has all the feature replacement Slither-format requires Slither and all its dependencies -## Known Limitations +## To-do List of Known Limitations -* Naming convention formatting on parameter uses does not work for NatSpec @param attributes -* Naming convention formatting on parameter uses does not work for variables used as indices on LHS (e.g. `_to` in `balances[_to] = 100`) +* Naming convention formatting on parameter uses does not work for NatSpec @param attributes. +* Naming convention formatting on parameter uses does not work for variables used as indices on LHS (e.g. `_to` in `balances[_to] = 100`). +* Overlapping patches are ignored now - Apply the more important patch based on heuristics or user input. +* Other to-do's as commented in the code. ## Developer Testing From f2b89aaa0b2ad9eade1d3ab2aa87a73c847457a7 Mon Sep 17 00:00:00 2001 From: rajeevgopalakrishna Date: Wed, 29 May 2019 08:51:55 +0530 Subject: [PATCH 045/223] slither-format: - Adds version (0.1.0) to options - Updates README to document the one expected failure --- utils/slither_format/README.md | 10 +++++----- utils/slither_format/__main__.py | 4 ++++ 2 files changed, 9 insertions(+), 5 deletions(-) diff --git a/utils/slither_format/README.md b/utils/slither_format/README.md index 91fda1b43..beae5b453 100644 --- a/utils/slither_format/README.md +++ b/utils/slither_format/README.md @@ -46,10 +46,10 @@ Slither-format requires Slither and all its dependencies ## To-do List of Known Limitations -* Naming convention formatting on parameter uses does not work for NatSpec @param attributes. -* Naming convention formatting on parameter uses does not work for variables used as indices on LHS (e.g. `_to` in `balances[_to] = 100`). -* Overlapping patches are ignored now - Apply the more important patch based on heuristics or user input. -* Other to-do's as commented in the code. +1. Naming convention formatting on parameter uses does not work for NatSpec @param attributes. +2. Naming convention formatting on parameter uses does not work for variables used as indices on LHS (e.g. `_to` in `balances[_to] = 100`). +3. Overlapping patches are ignored now - Apply the more important patch based on heuristics or user input. +4. Other to-do's as commented in the code. ## Developer Testing @@ -60,7 +60,7 @@ $ python3 ./slither_format/tests/test_constable_states.py $ python3 ./slither_format/tests/test_constant_function.py $ python3 ./slither_format/tests/test_solc_version.py $ python3 ./slither_format/tests/test_pragma.py -$ python3 ./slither_format/tests/test_naming_convention.py +$ python3 ./slither_format/tests/test_naming_convention.py (Has one expected failure because of limitation #2.) $ python3 ./slither_format/tests/test_detector_combinations.py $ python3 ./slither_format/tests/run_all_tests.py $ python3 ./slither_format/tests/runSlitherFormat.py diff --git a/utils/slither_format/__main__.py b/utils/slither_format/__main__.py index 7f23ca268..fdd1386f5 100644 --- a/utils/slither_format/__main__.py +++ b/utils/slither_format/__main__.py @@ -31,6 +31,10 @@ def parse_args(): parser.add_argument('filename', help='The filename of the contract or truffle directory to analyze.') parser.add_argument('--verbose-test', '-v', help='verbose mode output for testing',action='store_true',default=False) parser.add_argument('--verbose-json', '-j', help='verbose json output',action='store_true',default=False) + parser.add_argument('--version', + help='displays the current version', + version='0.1.0', + action='version') group_detector = parser.add_argument_group('Detectors') group_detector.add_argument('--detect', From 53a3bee4de2100b8e8826380d32a8e88701f51cd Mon Sep 17 00:00:00 2001 From: David Pokora Date: Wed, 29 May 2019 15:56:27 -0400 Subject: [PATCH 046/223] Updated standard output capturing to optionally mirror to stdout/stderr (needed for outputting JSON to file, which retains output to console as well). --- slither/__main__.py | 24 +++++---- slither/utils/output_capture.py | 90 ++++++++++++++++++++++++++++++++ slither/utils/output_redirect.py | 67 ------------------------ 3 files changed, 104 insertions(+), 77 deletions(-) create mode 100644 slither/utils/output_capture.py delete mode 100644 slither/utils/output_redirect.py diff --git a/slither/__main__.py b/slither/__main__.py index 38b5c25ef..7dbec0077 100644 --- a/slither/__main__.py +++ b/slither/__main__.py @@ -19,7 +19,7 @@ from slither.detectors.abstract_detector import (AbstractDetector, from slither.printers import all_printers from slither.printers.abstract_printer import AbstractPrinter from slither.slither import Slither -from slither.utils.output_redirect import StandardOutputRedirect +from slither.utils.output_capture import StandardOutputCapture from slither.utils.colors import red, yellow, set_colorization_enabled from slither.utils.command_line import (output_detectors, output_results_to_markdown, output_detectors_json, output_printers, @@ -109,8 +109,8 @@ def output_json(filename, error, results): "results": results } - # Determine if our filename is referring to stdout - if filename == "-": + # Determine if we should output to stdout + if filename is None: # Write json to console print(json.dumps(json_result)) else: @@ -511,12 +511,16 @@ def main_impl(all_detector_classes, all_printer_classes): # Set colorization option set_colorization_enabled(not args.disable_color) - # If we are outputting json to stdout, we'll want to define some variables and redirect stdout - output_error = None + # Define some variables for potential JSON output json_results = {} + output_error = None outputting_json = args.json is not None + outputting_json_stdout = args.json == '-' + + # If we are outputting JSON, capture all standard output. If we are outputting to stdout, we block typical stdout + # output. if outputting_json: - StandardOutputRedirect.enable() + StandardOutputCapture.enable(outputting_json_stdout) printer_classes = choose_printers(args, all_printer_classes) detector_classes = choose_detectors(args, all_detector_classes) @@ -602,10 +606,10 @@ def main_impl(all_detector_classes, all_printer_classes): # If we are outputting JSON, capture the redirected output and disable the redirect to output the final JSON. if outputting_json: - json_results['stdout'] = StandardOutputRedirect.get_stdout_output() - json_results['stderr'] = StandardOutputRedirect.get_stderr_output() - StandardOutputRedirect.disable() - output_json(args.json, output_error, json_results) + json_results['stdout'] = StandardOutputCapture.get_stdout_output() + json_results['stderr'] = StandardOutputCapture.get_stderr_output() + StandardOutputCapture.disable() + output_json(None if outputting_json_stdout else args.json, output_error, json_results) # Exit with the appropriate status code if output_error: diff --git a/slither/utils/output_capture.py b/slither/utils/output_capture.py new file mode 100644 index 000000000..d557ede1e --- /dev/null +++ b/slither/utils/output_capture.py @@ -0,0 +1,90 @@ +import io +import logging +import sys + + +class CapturingStringIO(io.StringIO): + """ + I/O implementation which captures output, and optionally mirrors it to the original I/O stream it replaces. + """ + def __init__(self, original_io=None): + super(CapturingStringIO, self).__init__() + self.original_io = original_io + + def write(self, s): + super().write(s) + if self.original_io: + self.original_io.write(s) + + +class StandardOutputCapture: + """ + Redirects and captures standard output/errors. + """ + original_stdout = None + original_stderr = None + original_logger_handlers = None + + @staticmethod + def enable(block_original=True): + """ + Redirects stdout and stderr to a capturable StringIO. + :param block_original: If True, blocks all output to the original stream. If False, duplicates output. + :return: None + """ + # Redirect stdout + if StandardOutputCapture.original_stdout is None: + StandardOutputCapture.original_stdout = sys.stdout + sys.stdout = CapturingStringIO(None if block_original else StandardOutputCapture.original_stdout) + + # Redirect stderr + if StandardOutputCapture.original_stderr is None: + StandardOutputCapture.original_stderr = sys.stderr + sys.stderr = CapturingStringIO(None if block_original else StandardOutputCapture.original_stderr) + + # Backup and swap root logger handlers + root_logger = logging.getLogger() + StandardOutputCapture.original_logger_handlers = root_logger.handlers + root_logger.handlers = [logging.StreamHandler(sys.stderr)] + + @staticmethod + def disable(): + """ + Disables redirection of stdout/stderr, if previously enabled. + :return: None + """ + # If we have a stdout backup, restore it. + if StandardOutputCapture.original_stdout is not None: + sys.stdout.close() + sys.stdout = StandardOutputCapture.original_stdout + StandardOutputCapture.original_stdout = None + + # If we have an stderr backup, restore it. + if StandardOutputCapture.original_stderr is not None: + sys.stderr.close() + sys.stderr = StandardOutputCapture.original_stderr + StandardOutputCapture.original_stderr = None + + # Restore our logging handlers + if StandardOutputCapture.original_logger_handlers is not None: + root_logger = logging.getLogger() + root_logger.handlers = StandardOutputCapture.original_logger_handlers + StandardOutputCapture.original_logger_handlers = None + + @staticmethod + def get_stdout_output(): + """ + Obtains the output from the currently set stdout + :return: Returns stdout output as a string + """ + sys.stdout.seek(0) + return sys.stdout.read() + + @staticmethod + def get_stderr_output(): + """ + Obtains the output from the currently set stderr + :return: Returns stderr output as a string + """ + sys.stderr.seek(0) + return sys.stderr.read() diff --git a/slither/utils/output_redirect.py b/slither/utils/output_redirect.py deleted file mode 100644 index 9811b21b2..000000000 --- a/slither/utils/output_redirect.py +++ /dev/null @@ -1,67 +0,0 @@ -import io -import logging -import sys - - -class StandardOutputRedirect: - """ - Redirects and captures standard output/errors. - """ - original_stdout = None - original_stderr = None - - @staticmethod - def enable(): - """ - Redirects stdout and/or stderr to a captureable StringIO. - :param redirect_stdout: True if redirection is desired for stdout. - :param redirect_stderr: True if redirection is desired for stderr. - :return: None - """ - # Redirect stdout - if StandardOutputRedirect.original_stdout is None: - StandardOutputRedirect.original_stdout = sys.stdout - sys.stdout = io.StringIO() - - # Redirect stderr - if StandardOutputRedirect.original_stderr is None: - StandardOutputRedirect.original_stderr = sys.stderr - sys.stderr = io.StringIO() - root_logger = logging.getLogger() - root_logger.handlers = [logging.StreamHandler(sys.stderr)] - - @staticmethod - def disable(): - """ - Disables redirection of stdout/stderr, if previously enabled. - :return: None - """ - # If we have a stdout backup, restore it. - if StandardOutputRedirect.original_stdout is not None: - sys.stdout.close() - sys.stdout = StandardOutputRedirect.original_stdout - StandardOutputRedirect.original_stdout = None - - # If we have an stderr backup, restore it. - if StandardOutputRedirect.original_stderr is not None: - sys.stderr.close() - sys.stderr = StandardOutputRedirect.original_stderr - StandardOutputRedirect.original_stderr = None - - @staticmethod - def get_stdout_output(): - """ - Obtains the output from stdout - :return: Returns stdout output as a string - """ - sys.stdout.seek(0) - return sys.stdout.read() - - @staticmethod - def get_stderr_output(): - """ - Obtains the output from stdout - :return: Returns stdout output as a string - """ - sys.stderr.seek(0) - return sys.stderr.read() \ No newline at end of file From e85848b9988e183800adc460c53c70e0935e0eb6 Mon Sep 17 00:00:00 2001 From: David Pokora Date: Thu, 30 May 2019 16:11:12 -0400 Subject: [PATCH 047/223] -Added --json-types command line argument to individually specify result output options. -Console output in JSON is now optional via --json-types -Detector types can be listed via --json-types now (retained --list-detectors-json for compatibility, to be deprecated later). --- slither/__main__.py | 39 +++++++++++++++++++++++++++++------ slither/utils/command_line.py | 5 +++-- 2 files changed, 36 insertions(+), 8 deletions(-) diff --git a/slither/__main__.py b/slither/__main__.py index 7dbec0077..73433d6f0 100644 --- a/slither/__main__.py +++ b/slither/__main__.py @@ -22,7 +22,7 @@ from slither.slither import Slither from slither.utils.output_capture import StandardOutputCapture from slither.utils.colors import red, yellow, set_colorization_enabled from slither.utils.command_line import (output_detectors, output_results_to_markdown, - output_detectors_json, output_printers, + get_detector_types_json, output_printers, output_to_markdown, output_wiki) from crytic_compile import is_supported from slither.exceptions import SlitherException @@ -30,6 +30,8 @@ from slither.exceptions import SlitherException logging.basicConfig() logger = logging.getLogger("Slither") +JSON_OUTPUT_TYPES = ["console", "detectors", "detector-types"] + ################################################################################### ################################################################################### # region Process functions @@ -256,6 +258,7 @@ defaults_flag_in_config = { 'solc_args': None, 'disable_solc_warnings': False, 'json': None, + 'json-types': ','.join(JSON_OUTPUT_TYPES), 'truffle_version': None, 'disable_color': False, 'filter_paths': None, @@ -345,6 +348,13 @@ def parse_args(detector_classes, printer_classes): action='store', default=defaults_flag_in_config['json']) + group_misc.add_argument('--json-types', + help='Comma-separated list of result types to output to JSON, defaults to all, ' + 'available types: {}'.format( + ', '.join(output_type for output_type in JSON_OUTPUT_TYPES)), + action='store', + default=defaults_flag_in_config['json-types']) + group_misc.add_argument('--disable-color', help='Disable output colorization', action='store_true', @@ -435,6 +445,12 @@ def parse_args(detector_classes, printer_classes): except json.decoder.JSONDecodeError as e: logger.error(red('Impossible to read {}, please check the file {}'.format(args.config_file, e))) + # Verify our json-type output is valid + args.json_types = set(args.json_types.split(',')) + for json_type in args.json_types: + if json_type not in JSON_OUTPUT_TYPES: + raise Exception(f"Error: \"{json_type}\" is not a valid JSON result output type.") + return args class ListDetectors(argparse.Action): @@ -446,7 +462,8 @@ class ListDetectors(argparse.Action): class ListDetectorsJson(argparse.Action): def __call__(self, parser, *args, **kwargs): detectors, _ = get_detectors_and_printers() - output_detectors_json(detectors) + detector_types_json = get_detector_types_json(detectors) + print(json.dumps(detector_types_json)) parser.exit() class ListPrinters(argparse.Action): @@ -579,8 +596,17 @@ def main_impl(all_detector_classes, all_printer_classes): else: raise Exception("Unrecognised file/dir path: '#{filename}'".format(filename=filename)) - if args.json and results: - json_results['detectors'] = results + # Determine if we are outputting JSON + if outputting_json: + # Add our detector results to JSON if desired. + if results and 'detectors' in args.json_types: + json_results['detectors'] = results + + # Add our detector types to JSON + if 'detector-types' in args.json_types: + detectors, _ = get_detectors_and_printers() + json_results['detector-types'] = get_detector_types_json(detectors) + if args.checklist: output_results_to_markdown(results) # Dont print the number of result for printers @@ -606,8 +632,9 @@ def main_impl(all_detector_classes, all_printer_classes): # If we are outputting JSON, capture the redirected output and disable the redirect to output the final JSON. if outputting_json: - json_results['stdout'] = StandardOutputCapture.get_stdout_output() - json_results['stderr'] = StandardOutputCapture.get_stderr_output() + if 'console' in args.json_types: + json_results['stdout'] = StandardOutputCapture.get_stdout_output() + json_results['stderr'] = StandardOutputCapture.get_stderr_output() StandardOutputCapture.disable() output_json(None if outputting_json_stdout else args.json, output_error, json_results) diff --git a/slither/utils/command_line.py b/slither/utils/command_line.py index d1a495a23..531181c4a 100644 --- a/slither/utils/command_line.py +++ b/slither/utils/command_line.py @@ -155,7 +155,8 @@ def output_detectors(detector_classes): idx = idx + 1 print(table) -def output_detectors_json(detector_classes): + +def get_detector_types_json(detector_classes): detectors_list = [] for detector in detector_classes: argument = detector.ARGUMENT @@ -193,7 +194,7 @@ def output_detectors_json(detector_classes): 'exploit_scenario':exploit, 'recommendation':recommendation}) idx = idx + 1 - print(json.dumps(table)) + return table def output_printers(printer_classes): printers_list = [] From f526a74071976125a233bdd9daf4bf1ff433760c Mon Sep 17 00:00:00 2001 From: David Pokora Date: Thu, 30 May 2019 18:57:07 -0400 Subject: [PATCH 048/223] Added json result types for compilation (ast, bytecode, srcmap, filenames, etc). --- slither/__main__.py | 33 ++++++++++++++++++++++++++------- 1 file changed, 26 insertions(+), 7 deletions(-) diff --git a/slither/__main__.py b/slither/__main__.py index 73433d6f0..ea386504e 100644 --- a/slither/__main__.py +++ b/slither/__main__.py @@ -30,7 +30,7 @@ from slither.exceptions import SlitherException logging.basicConfig() logger = logging.getLogger("Slither") -JSON_OUTPUT_TYPES = ["console", "detectors", "detector-types"] +JSON_OUTPUT_TYPES = ["compilation", "console", "detectors", "detector-types"] ################################################################################### ################################################################################### @@ -75,7 +75,7 @@ def _process(slither, detector_classes, printer_classes): slither.run_printers() # Currently printers does not return results - return results, analyzed_contracts_count + return slither, results, analyzed_contracts_count def process_files(filenames, args, detector_classes, printer_classes): @@ -576,7 +576,7 @@ def main_impl(all_detector_classes, all_printer_classes): globbed_filenames = glob.glob(filename, recursive=True) if os.path.isfile(filename) or is_supported(filename): - (results, number_contracts) = process(filename, args, detector_classes, printer_classes) + (slither, results, number_contracts) = process(filename, args, detector_classes, printer_classes) elif os.path.isdir(filename) or len(globbed_filenames) > 0: extension = "*.sol" if not args.solc_ast else "*.json" @@ -586,10 +586,10 @@ def main_impl(all_detector_classes, all_printer_classes): number_contracts = 0 results = [] if args.splitted and args.solc_ast: - (results, number_contracts) = process_files(filenames, args, detector_classes, printer_classes) + (slither, results, number_contracts) = process_files(filenames, args, detector_classes, printer_classes) else: for filename in filenames: - (results_tmp, number_contracts_tmp) = process(filename, args, detector_classes, printer_classes) + (slither, results_tmp, number_contracts_tmp) = process(filename, args, detector_classes, printer_classes) number_contracts += number_contracts_tmp results += results_tmp @@ -598,6 +598,21 @@ def main_impl(all_detector_classes, all_printer_classes): # Determine if we are outputting JSON if outputting_json: + # Add our compilation information to JSON + if 'compilation' in args.json_types: + json_results['compilation'] = { + "abis": slither.crytic_compile.abis, + "asts": slither.crytic_compile.asts, + "bytecodes_init": slither.crytic_compile.bytecodes_init, + "bytecodes_runtime": slither.crytic_compile.bytecodes_runtime, + "compiler_version": slither.crytic_compile.compiler_version, + "contracts_filenames": { key: value._asdict() for key, value in slither.crytic_compile.contracts_filenames.items()}, + "filenames": [x._asdict() for x in slither.crytic_compile.filenames], + "srcmaps_init": slither.crytic_compile.srcmaps_init, + "srcmaps_runtime": slither.crytic_compile.srcmaps_runtime, + "type": str(slither.crytic_compile.type) + } + # Add our detector results to JSON if desired. if results and 'detectors' in args.json_types: json_results['detectors'] = results @@ -607,8 +622,10 @@ def main_impl(all_detector_classes, all_printer_classes): detectors, _ = get_detectors_and_printers() json_results['detector-types'] = get_detector_types_json(detectors) + # Output our results to markdown if we wish to compile a checklist. if args.checklist: output_results_to_markdown(results) + # Dont print the number of result for printers if number_contracts == 0: logger.warn(red('No contract was analyzed')) @@ -633,8 +650,10 @@ def main_impl(all_detector_classes, all_printer_classes): # If we are outputting JSON, capture the redirected output and disable the redirect to output the final JSON. if outputting_json: if 'console' in args.json_types: - json_results['stdout'] = StandardOutputCapture.get_stdout_output() - json_results['stderr'] = StandardOutputCapture.get_stderr_output() + json_results['console'] = { + 'stdout': StandardOutputCapture.get_stdout_output(), + 'stderr': StandardOutputCapture.get_stderr_output() + } StandardOutputCapture.disable() output_json(None if outputting_json_stdout else args.json, output_error, json_results) From 5d88be8328522efe84d3c0c13803d9366de2b44c Mon Sep 17 00:00:00 2001 From: Eric Rafaloff Date: Wed, 12 Jun 2019 11:26:04 -0400 Subject: [PATCH 049/223] Detect Aragon OS --- slither/utils/standard_libraries.py | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/slither/utils/standard_libraries.py b/slither/utils/standard_libraries.py index c73a29b93..8ae3e5978 100644 --- a/slither/utils/standard_libraries.py +++ b/slither/utils/standard_libraries.py @@ -13,6 +13,7 @@ libraries = { 'Dapphub-DSToken': lambda x: is_dapphub_ds_token(x), 'Dapphub-DSProxy': lambda x: is_dapphub_ds_proxy(x), 'Dapphub-DSGroup': lambda x: is_dapphub_ds_group(x), + 'AragonOS-App': lambda x: is_aragonos_app(x) } def is_standard_library(contract): @@ -41,6 +42,12 @@ def is_zos(contract): return 'zos-lib' in Path(contract.source_mapping['filename_absolute']).parts +def is_aragonos(contract): + if not contract.is_from_dependency(): + return False + return '@aragon/os' in Path(contract.source_mapping['filename_absolute']).parts + + # endregion ################################################################################### ################################################################################### @@ -191,3 +198,13 @@ def is_ds_group(contract): def is_dapphub_ds_group(contract): return _is_dappdhub_ds(contract, 'DSGroup') + +# endregion +################################################################################### +################################################################################### +# region Aragon +################################################################################### +################################################################################### + +def is_aragonos_app(contract): + return contract.name == "AragonApp" and is_aragonos(contract) From bc1cb0df2dd3041cbe3c46228a36054a70eb0833 Mon Sep 17 00:00:00 2001 From: Eric Rafaloff Date: Wed, 12 Jun 2019 12:22:11 -0400 Subject: [PATCH 050/223] Add --exclude-optimization flag --- slither/__main__.py | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/slither/__main__.py b/slither/__main__.py index a1b4ce4ad..52a0fc4ca 100644 --- a/slither/__main__.py +++ b/slither/__main__.py @@ -203,6 +203,10 @@ def choose_detectors(args, all_detector_classes): detectors_to_run = sorted(detectors_to_run, key=lambda x: x.IMPACT) return detectors_to_run + if args.exclude_optimization: + detectors_to_run = [d for d in detectors_to_run if + d.IMPACT != DetectorClassification.OPTIMIZATION] + if args.exclude_informational: detectors_to_run = [d for d in detectors_to_run if d.IMPACT != DetectorClassification.INFORMATIONAL] @@ -260,6 +264,7 @@ defaults_flag_in_config = { 'printers_to_run': None, 'detectors_to_exclude': None, 'exclude_dependencies': False, + 'exclude_optimization': False, 'exclude_informational': False, 'exclude_low': False, 'exclude_medium': False, @@ -337,6 +342,11 @@ def parse_args(detector_classes, printer_classes): action='store_true', default=defaults_flag_in_config['exclude_dependencies']) + group_detector.add_argument('--exclude-optimization', + help='Exclude optimization analyses', + action='store_true', + default=defaults_flag_in_config['exclude_optimization']) + group_detector.add_argument('--exclude-informational', help='Exclude informational impact analyses', action='store_true', From 99ad5b1bf3eb53fadac8bd74802d12e7eceed0a0 Mon Sep 17 00:00:00 2001 From: Josselin Date: Thu, 13 Jun 2019 10:56:10 +0200 Subject: [PATCH 051/223] Add CONTRIBUTING.md --- CONTRIBUTING.md | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) create mode 100644 CONTRIBUTING.md diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md new file mode 100644 index 000000000..c5b078541 --- /dev/null +++ b/CONTRIBUTING.md @@ -0,0 +1,24 @@ +# Contributing to Manticore +First, thanks for your interest in contributing to Slither! We welcome and appreciate all contributions, including bug reports, feature suggestions, tutorials/blog posts, and code improvements. + +If you're unsure where to start, we recommend our [`good first issue`](https://github.com/crytic/slither/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22) and [`help wanted`](https://github.com/crytic/slither/issues?q=is%3Aissue+is%3Aopen+label%3A%22help+wanted%22) issue labels. + +# Bug reports and feature suggestions +Bug reports and feature suggestions can be submitted to our issue tracker. For bug reports, attaching the contract that caused the bug will help us in debugging and resolving the issue quickly. If you find a security vulnerability, do not open an issue; email opensource@trailofbits.com instead. + +# Questions +Questions can be submitted to the issue tracker, but you may get a faster response if you ask in our [chat room](https://empireslacking.herokuapp.com/) (in the #ethereum channel). + +# Code +Slither uses the pull request contribution model. Please make an account on Github, fork this repo, and submit code contributions via pull request. For more documentation, look [here](https://guides.github.com/activities/forking/). + +Some pull request guidelines: + +- Work from the [`dev`](https://github.com/crytic/slither/tree/dev) branch. We performed extensive tests prior to merging anything to `master`, working from `dev` will allow us to merge your work faster. +- Minimize irrelevant changes (formatting, whitespace, etc) to code that would otherwise not be touched by this patch. Save formatting or style corrections for a separate pull request that does not make any semantic changes. +- When possible, large changes should be split up into smaller focused pull requests. +- Fill out the pull request description with a summary of what your patch does, key changes that have been made, and any further points of discussion, if applicable. +- Title your pull request with a brief description of what it's changing. "Fixes #123" is a good comment to add to the description, but makes for an unclear title on its own. + +# Development Environment +Instructions for installing a development version of Slither can be found in our [wiki](https://github.com/crytic/slither/wiki/Developer-installation). From b275bcc824b1b932310cf03b6bfb1a1fef0ebae1 Mon Sep 17 00:00:00 2001 From: Josselin Date: Thu, 13 Jun 2019 11:27:37 +0200 Subject: [PATCH 052/223] Add demo utility --- utils/demo/README.md | 6 ++++++ utils/demo/__init__.py | 0 utils/demo/__main__.py | 38 ++++++++++++++++++++++++++++++++++++++ 3 files changed, 44 insertions(+) create mode 100644 utils/demo/README.md create mode 100644 utils/demo/__init__.py create mode 100644 utils/demo/__main__.py diff --git a/utils/demo/README.md b/utils/demo/README.md new file mode 100644 index 000000000..00bdec0b4 --- /dev/null +++ b/utils/demo/README.md @@ -0,0 +1,6 @@ +## Demo + +This directory contains an example of Slither utility. + +See the [utility documentation](https://github.com/crytic/slither/wiki/Adding-a-new-utility) + diff --git a/utils/demo/__init__.py b/utils/demo/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/utils/demo/__main__.py b/utils/demo/__main__.py new file mode 100644 index 000000000..4bee3b449 --- /dev/null +++ b/utils/demo/__main__.py @@ -0,0 +1,38 @@ +import os +import argparse +import logging +from slither import Slither +from crytic_compile import cryticparser + +logging.basicConfig() +logging.getLogger("Slither").setLevel(logging.INFO) + +logger = logging.getLogger("Slither-demo") + +def parse_args(): + """ + Parse the underlying arguments for the program. + :return: Returns the arguments for the program. + """ + parser = argparse.ArgumentParser(description='Demo', + usage='slither-demo filename') + + parser.add_argument('filename', + help='The filename of the contract or truffle directory to analyze.') + + # Add default arguments from crytic-compile + cryticparser.init(parser) + + return parser.parse_args() + + +def main(): + args = parse_args() + + # Perform slither analysis on the given filename + slither = Slither(args.filename, **vars(args)) + + logger.info('Analysis done!') + +if __name__ == '__main__': + main() From 5b0a7887667727e6e17b2cf92db8e9b6f0eca01b Mon Sep 17 00:00:00 2001 From: Josselin Date: Tue, 18 Jun 2019 16:33:08 +0200 Subject: [PATCH 053/223] slither-format: clean code --- utils/slither_format/README.md | 2 +- utils/slither_format/slither_format.py | 34 ++++++++++++++++---------- 2 files changed, 22 insertions(+), 14 deletions(-) diff --git a/utils/slither_format/README.md b/utils/slither_format/README.md index c3f291655..b0e0468a8 100644 --- a/utils/slither_format/README.md +++ b/utils/slither_format/README.md @@ -29,7 +29,7 @@ Slither detectors highlight names, context and source-mapping of code constructs Run Slither-format on a single file: ``` -$ python3 -m slither-format ./utils/slither_format/tests/test_data/constant.sol +$ slither-format ./utils/slither_format/tests/test_data/constant.sol ``` This produces `constant.sol.format` file which has all the feature replacements. diff --git a/utils/slither_format/slither_format.py b/utils/slither_format/slither_format.py index 8838ba071..aee4ce106 100644 --- a/utils/slither_format/slither_format.py +++ b/utils/slither_format/slither_format.py @@ -58,17 +58,21 @@ 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): + 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 - if ((int(patches[file][j]['start']) >= int(patches[file][j+1]['start']) and - int(patches[file][j]['start']) <= int(patches[file][j+1]['end'])) or - (int(patches[file][j+1]['start']) >= int(patches[file][j]['start']) and - int(patches[file][j+1]['start']) <= int(patches[file][j]['end']))): + 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" @@ -92,22 +96,26 @@ def prune_overlapping_patches(args, patches): def generate_patch_files(slither, patches): for file in patches: _in_file = file - if patches[file]: - in_file_str = slither.source_code[patches[file][0]['file']].encode('utf-8') + 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(patches[file])): + for i in range(len(current_patches)): if i != 0: - out_file_str += in_file_str[int(patches[file][i-1]['end']):int(patches[file][i]['start'])].decode('utf-8') + 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(patches[file][i]['start'])].decode('utf-8') - out_file_str += patches[file][i]['new_string'] - if (i == (len(patches[file]) - 1)): - out_file_str += in_file_str[int(patches[file][i]['end']):].decode('utf-8') + 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() From 9f8340e74334ae4be4eaff0f399f20794842ee0c Mon Sep 17 00:00:00 2001 From: Ankur Sundara Date: Wed, 19 Jun 2019 19:15:11 -0400 Subject: [PATCH 054/223] add is_fallback parameter --- slither/core/declarations/function.py | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/slither/core/declarations/function.py b/slither/core/declarations/function.py index 1f7247102..b5fa6712c 100644 --- a/slither/core/declarations/function.py +++ b/slither/core/declarations/function.py @@ -986,6 +986,14 @@ class Function(ChildContract, ChildInheritance, SourceMapping): args_vars = self.all_solidity_variables_used_as_args() return SolidityVariableComposed('msg.sender') in conditional_vars + args_vars + def is_fallback(self): + """ + Determine if the function is the fallback function for the contract + Returns + (bool) + """ + return self._name == "" and not self.is_constructor + # endregion ################################################################################### ################################################################################### From a1ecf122588301f5f7b991e0710ff9e7a71e6550 Mon Sep 17 00:00:00 2001 From: Ankur Sundara Date: Wed, 19 Jun 2019 19:31:43 -0400 Subject: [PATCH 055/223] set type of constants --- slither/visitors/slithir/expression_to_slithir.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/slither/visitors/slithir/expression_to_slithir.py b/slither/visitors/slithir/expression_to_slithir.py index 7799cf128..753bd82eb 100644 --- a/slither/visitors/slithir/expression_to_slithir.py +++ b/slither/visitors/slithir/expression_to_slithir.py @@ -227,32 +227,32 @@ class ExpressionToSlithIR(ExpressionVisitor): self._result.append(operation) set_val(expression, value) elif expression.type in [UnaryOperationType.PLUSPLUS_PRE]: - operation = Binary(value, value, Constant("1"), BinaryType.ADDITION) + operation = Binary(value, value, Constant("1", value.type), BinaryType.ADDITION) self._result.append(operation) set_val(expression, value) elif expression.type in [UnaryOperationType.MINUSMINUS_PRE]: - operation = Binary(value, value, Constant("1"), BinaryType.SUBTRACTION) + operation = Binary(value, value, Constant("1", value.type), BinaryType.SUBTRACTION) self._result.append(operation) set_val(expression, value) elif expression.type in [UnaryOperationType.PLUSPLUS_POST]: lvalue = TemporaryVariable(self._node) operation = Assignment(lvalue, value, value.type) self._result.append(operation) - operation = Binary(value, value, Constant("1"), BinaryType.ADDITION) + operation = Binary(value, value, Constant("1", value.type), BinaryType.ADDITION) self._result.append(operation) set_val(expression, lvalue) elif expression.type in [UnaryOperationType.MINUSMINUS_POST]: lvalue = TemporaryVariable(self._node) operation = Assignment(lvalue, value, value.type) self._result.append(operation) - operation = Binary(value, value, Constant("1"), BinaryType.SUBTRACTION) + operation = Binary(value, value, Constant("1", value.type), BinaryType.SUBTRACTION) self._result.append(operation) set_val(expression, lvalue) elif expression.type in [UnaryOperationType.PLUS_PRE]: set_val(expression, value) elif expression.type in [UnaryOperationType.MINUS_PRE]: lvalue = TemporaryVariable(self._node) - operation = Binary(lvalue, Constant("0"), value, BinaryType.SUBTRACTION) + operation = Binary(lvalue, Constant("0", value.type), value, BinaryType.SUBTRACTION) self._result.append(operation) set_val(expression, lvalue) else: From df17fb877996da93a62872d6b78402aeeca9a556 Mon Sep 17 00:00:00 2001 From: Eric Rafaloff Date: Thu, 20 Jun 2019 10:50:03 -0400 Subject: [PATCH 056/223] Detect more AragonOS contracts --- slither/utils/standard_libraries.py | 78 ++++++++++++++++++++++++++++- 1 file changed, 76 insertions(+), 2 deletions(-) diff --git a/slither/utils/standard_libraries.py b/slither/utils/standard_libraries.py index 8ae3e5978..d1c0bdbec 100644 --- a/slither/utils/standard_libraries.py +++ b/slither/utils/standard_libraries.py @@ -13,7 +13,24 @@ libraries = { 'Dapphub-DSToken': lambda x: is_dapphub_ds_token(x), 'Dapphub-DSProxy': lambda x: is_dapphub_ds_proxy(x), 'Dapphub-DSGroup': lambda x: is_dapphub_ds_group(x), - 'AragonOS-App': lambda x: is_aragonos_app(x) + 'AragonOS-SafeMath': lambda x: is_aragonos_safemath(x), + 'AragonOS-ERC20': lambda x: is_aragonos_erc20(x), + 'AragonOS-AppProxyBase': lambda x: is_aragonos_app_proxy_base(x), + 'AragonOS-AppProxyPinned': lambda x: is_aragonos_app_proxy_pinned(x), + 'AragonOS-AppProxyUpgradeable': lambda x: is_aragonos_app_proxy_upgradeable(x), + 'AragonOS-AppStorage': lambda x: is_aragonos_app_storage(x), + 'AragonOS-AragonApp': lambda x: is_aragonos_aragon_app(x), + 'AragonOS-UnsafeAragonApp': lambda x: is_aragonos_unsafe_aragon_app(x), + 'AragonOS-Autopetrified': lambda x: is_aragonos_autopetrified(x), + 'AragonOS-DelegateProxy': lambda x: is_aragonos_delegate_proxy(x), + 'AragonOS-DepositableDelegateProxy': lambda x: is_aragonos_depositable_delegate_proxy(x), + 'AragonOS-DepositableStorage': lambda x: is_aragonos_delegate_proxy(x), + 'AragonOS-Initializable': lambda x: is_aragonos_initializable(x), + 'AragonOS-IsContract': lambda x: is_aragonos_is_contract(x), + 'AragonOS-Petrifiable': lambda x: is_aragonos_petrifiable(x), + 'AragonOS-ReentrancyGuard': lambda x: is_aragonos_reentrancy_guard(x), + 'AragonOS-TimeHelpers': lambda x: is_aragonos_time_helpers(x), + 'AragonOS-VaultRecoverable': lambda x: is_aragonos_vault_recoverable(x) } def is_standard_library(contract): @@ -63,6 +80,11 @@ def is_safemath(contract): def is_openzepellin_safemath(contract): return is_safemath(contract) and is_openzepellin(contract) + +def is_aragonos_safemath(contract): + return is_safemath(contract) and is_aragonos(contract) + + # endregion ################################################################################### ################################################################################### @@ -111,6 +133,10 @@ def is_openzepellin_erc20(contract): return is_erc20(contract) and is_openzepellin(contract) +def is_aragonos_erc20(contract): + return is_erc20(contract) and is_openzepellin(contract) + + # endregion ################################################################################### ################################################################################### @@ -206,5 +232,53 @@ def is_dapphub_ds_group(contract): ################################################################################### ################################################################################### -def is_aragonos_app(contract): +def is_aragonos_app_proxy_base(contract): + return contract.name == "AppProxyBase" and is_aragonos(contract) + +def is_aragonos_app_proxy_pinned(contract): + return contract.name == "AppProxyPinned" and is_aragonos(contract) + +def is_aragonos_app_proxy_upgradeable(contract): + return contract.name == "AppProxyUpgradeable" and is_aragonos(contract) + +def is_aragonos_app_storage(contract): + return contract.name == "AppStorage" and is_aragonos(contract) + +def is_aragonos_aragon_app(contract): return contract.name == "AragonApp" and is_aragonos(contract) + +def is_aragonos_unsafe_aragon_app(contract): + return contract.name == "UnsafeAragonApp" and is_aragonos(contract) + +def is_aragonos_autopetrified(contract): + return contract.name == "Autopetrified" and is_aragonos(contract) + +def is_aragonos_delegate_proxy(contract): + return contract.name == "DelegateProxy" and is_aragonos(contract) + +def is_aragonos_depositable_delegate_proxy(contract): + return contract.name == "DepositableDelegateProxy" and is_aragonos(contract) + +def is_aragonos_depositable_storage(contract): + return contract.name == "DepositableStorage" and is_aragonos(contract) + +def is_aragonos_ether_token_contract(contract): + return contract.name == "EtherTokenConstant" and is_aragonos(contract) + +def is_aragonos_initializable(contract): + return contract.name == "Initializable" and is_aragonos(contract) + +def is_aragonos_is_contract(contract): + return contract.name == "IsContract" and is_aragonos(contract) + +def is_aragonos_petrifiable(contract): + return contract.name == "Petrifiable" and is_aragonos(contract) + +def is_aragonos_reentrancy_guard(contract): + return contract.name == "ReentrancyGuard" and is_aragonos(contract) + +def is_aragonos_time_helpers(contract): + return contract.name == "TimeHelpers" and is_aragonos(contract) + +def is_aragonos_vault_recoverable(contract): + return contract.name == "VaultRecoverable" and is_aragonos(contract) From 76eb43930a000cffecb598df10f749550ab74dc0 Mon Sep 17 00:00:00 2001 From: Eric Rafaloff Date: Thu, 20 Jun 2019 10:50:46 -0400 Subject: [PATCH 057/223] Fix typo in check --- slither/utils/standard_libraries.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/slither/utils/standard_libraries.py b/slither/utils/standard_libraries.py index d1c0bdbec..e138e6c35 100644 --- a/slither/utils/standard_libraries.py +++ b/slither/utils/standard_libraries.py @@ -134,7 +134,7 @@ def is_openzepellin_erc20(contract): def is_aragonos_erc20(contract): - return is_erc20(contract) and is_openzepellin(contract) + return is_erc20(contract) and is_aragonos(contract) # endregion From 2d8e4bb1f1dd745d47a2f754793bc91cfee73fe5 Mon Sep 17 00:00:00 2001 From: David Pokora Date: Thu, 20 Jun 2019 17:27:31 -0400 Subject: [PATCH 058/223] -Added support for self-contained archives exported by crytic compile. -Rewrote main entry point to move glob pattern matching and other compilation into crytic compile. --- slither/__main__.py | 55 ++++++++++--------- slither/core/slither_core.py | 7 ++- slither/core/source_mapping/source_mapping.py | 13 +++-- slither/slither.py | 19 ++++--- 4 files changed, 55 insertions(+), 39 deletions(-) diff --git a/slither/__main__.py b/slither/__main__.py index a1b4ce4ad..01f3de96e 100644 --- a/slither/__main__.py +++ b/slither/__main__.py @@ -23,7 +23,7 @@ from slither.utils.colors import red, yellow, set_colorization_enabled from slither.utils.command_line import (output_detectors, output_results_to_markdown, output_detectors_json, output_printers, output_to_markdown, output_wiki) -from crytic_compile import is_supported +from crytic_compile import CryticCompile from slither.exceptions import SlitherException logging.basicConfig() @@ -35,7 +35,8 @@ logger = logging.getLogger("Slither") ################################################################################### ################################################################################### -def process(filename, args, detector_classes, printer_classes): + +def process_single(target, args, detector_classes, printer_classes): """ The core high-level code for running Slither static analysis. @@ -46,12 +47,25 @@ def process(filename, args, detector_classes, printer_classes): if args.legacy_ast: ast = '--ast-json' args.filter_paths = parse_filter_paths(args) - slither = Slither(filename, + slither = Slither(target, ast_format=ast, + solc_arguments=args.solc_args, **vars(args)) return _process(slither, detector_classes, printer_classes) + +def process_all(target, args, detector_classes, printer_classes): + compilations = CryticCompile.compile_all(target, **vars(args)) + results = [] + analyzed_contracts_count = 0 + for compilation in compilations: + (current_results, current_analyzed_count) = process_single(compilation, args, detector_classes, printer_classes) + results.extend(current_results) + analyzed_contracts_count += current_analyzed_count + return results, analyzed_contracts_count + + def _process(slither, detector_classes, printer_classes): for detector_cls in detector_classes: slither.register_detector(detector_cls) @@ -75,7 +89,7 @@ def _process(slither, detector_classes, printer_classes): return results, analyzed_contracts_count -def process_files(filenames, args, detector_classes, printer_classes): +def process_from_asts(filenames, args, detector_classes, printer_classes): all_contracts = [] for filename in filenames: @@ -83,15 +97,9 @@ def process_files(filenames, args, detector_classes, printer_classes): contract_loaded = json.load(f) all_contracts.append(contract_loaded['ast']) - slither = Slither(all_contracts, - solc=args.solc, - disable_solc_warnings=args.disable_solc_warnings, - solc_arguments=args.solc_args, - filter_paths=parse_filter_paths(args), - triage_mode=args.triage_mode, - exclude_dependencies=args.exclude_dependencies) + return process_single(all_contracts, args, detector_classes, printer_classes) + - return _process(slither, detector_classes, printer_classes) # endregion ################################################################################### @@ -296,7 +304,7 @@ def parse_args(detector_classes, printer_classes): group_detector = parser.add_argument_group('Detectors') group_printer = parser.add_argument_group('Printers') - group_misc = parser.add_argument_group('Additional option') + group_misc = parser.add_argument_group('Additional options') group_detector.add_argument('--detect', help='Comma-separated list of detectors, defaults to all, ' @@ -570,28 +578,25 @@ def main_impl(all_detector_classes, all_printer_classes): try: filename = args.filename - globbed_filenames = glob.glob(filename, recursive=True) - - if os.path.isfile(filename) or is_supported(filename): - (results, number_contracts) = process(filename, args, detector_classes, printer_classes) - - elif os.path.isdir(filename) or len(globbed_filenames) > 0: - extension = "*.sol" if not args.solc_ast else "*.json" - filenames = glob.glob(os.path.join(filename, extension)) + # Determine if we are handling ast from solc + if args.solc_ast: + globbed_filenames = glob.glob(filename, recursive=True) + filenames = glob.glob(os.path.join(filename, "*.json")) if not filenames: filenames = globbed_filenames number_contracts = 0 results = [] - if args.splitted and args.solc_ast: - (results, number_contracts) = process_files(filenames, args, detector_classes, printer_classes) + if args.splitted: + (results, number_contracts) = process_from_asts(filenames, args, detector_classes, printer_classes) else: for filename in filenames: - (results_tmp, number_contracts_tmp) = process(filename, args, detector_classes, printer_classes) + (results_tmp, number_contracts_tmp) = process_single(filename, args, detector_classes, printer_classes) number_contracts += number_contracts_tmp results += results_tmp + # Rely on CryticCompile to discern the underlying type of compilations. else: - raise Exception("Unrecognised file/dir path: '#{filename}'".format(filename=filename)) + (results, number_contracts) = process_all(filename, args, detector_classes, printer_classes) if args.json: output_json(results, None if stdout_json else args.json) diff --git a/slither/core/slither_core.py b/slither/core/slither_core.py index 94bd7eb35..f10831ffe 100644 --- a/slither/core/slither_core.py +++ b/slither/core/slither_core.py @@ -61,8 +61,11 @@ class Slither(Context): :param path: :return: """ - with open(path, encoding='utf8', newline='') as f: - self.source_code[path] = f.read() + if path in self.crytic_compile.src_content: + self.source_code[path] = self.crytic_compile.src_content[path] + else: + with open(path, encoding='utf8', newline='') as f: + self.source_code[path] = f.read() # endregion ################################################################################### diff --git a/slither/core/source_mapping/source_mapping.py b/slither/core/source_mapping/source_mapping.py index 9217b12fc..8f922c05c 100644 --- a/slither/core/source_mapping/source_mapping.py +++ b/slither/core/source_mapping/source_mapping.py @@ -90,18 +90,23 @@ class SourceMapping(Context): is_dependency = slither.crytic_compile.is_dependency(filename_absolute) - if filename_absolute in slither.source_code: + if filename_absolute in slither.source_code or filename_absolute in slither.crytic_compile.src_content: filename = filename_absolute elif filename_relative in slither.source_code: filename = filename_relative elif filename_short in slither.source_code: filename = filename_short - else:# - filename = filename_used.used + else: + filename = filename_used else: filename = filename_used - if filename in slither.source_code: + if filename in slither.crytic_compile.src_content: + source_code = slither.crytic_compile.src_content[filename] + (lines, starting_column, ending_column) = SourceMapping._compute_line(source_code, + s, + l) + elif filename in slither.source_code: source_code = slither.source_code[filename] (lines, starting_column, ending_column) = SourceMapping._compute_line(source_code, s, diff --git a/slither/slither.py b/slither/slither.py index d0c0ccf02..9a7732404 100644 --- a/slither/slither.py +++ b/slither/slither.py @@ -22,14 +22,14 @@ logger_printer = logging.getLogger("Printers") class Slither(SlitherSolc): - def __init__(self, contract, **kwargs): + def __init__(self, target, **kwargs): ''' Args: - contract (str| list(json)) + target (str | list(json) | CryticCompile) Keyword Args: solc (str): solc binary location (default 'solc') disable_solc_warnings (bool): True to disable solc warnings (default false) - solc_argeuments (str): solc arguments (default '') + solc_arguments (str): solc arguments (default '') ast_format (str): ast format (default '--ast-compact-json') filter_paths (list(str)): list of path to filter (default []) triage_mode (bool): if true, switch to triage mode (default false) @@ -46,14 +46,17 @@ class Slither(SlitherSolc): ''' # list of files provided (see --splitted option) - if isinstance(contract, list): - self._init_from_list(contract) - elif contract.endswith('.json'): - self._init_from_raw_json(contract) + if isinstance(target, list): + self._init_from_list(target) + elif isinstance(target, str) and target.endswith('.json'): + self._init_from_raw_json(target) else: super(Slither, self).__init__('') try: - crytic_compile = CryticCompile(contract, **kwargs) + if isinstance(target, CryticCompile): + crytic_compile = target + else: + crytic_compile = CryticCompile(target, **kwargs) self._crytic_compile = crytic_compile except InvalidCompilation as e: raise SlitherError('Invalid compilation: \n'+str(e)) From a0f7be75de316107a1ab65518d54cd8cc05d238e Mon Sep 17 00:00:00 2001 From: Josselin Date: Mon, 24 Jun 2019 13:56:51 +0200 Subject: [PATCH 059/223] slither-format: - move formater to utils/slither_format.formatters - create slither_format.utils.patches.create_patch, use it everywhere - remove sys.exit, in favor of slither exception - clean code, remove unused parameters, unused import, break lines too long Todo: naming convention --- utils/slither_format/format_unused_state.py | 24 --------- .../constable_states.py} | 32 ++++++------ .../constant_function.py} | 39 ++++++-------- .../external_function.py} | 52 +++++++++---------- .../naming_convention.py} | 4 +- .../pragma.py} | 44 +++++++--------- .../solc_version.py} | 34 +++++------- .../slither_format/formatters/unused_state.py | 29 +++++++++++ utils/slither_format/slither_format.py | 22 ++++---- utils/slither_format/utils/patches.py | 10 ++++ 10 files changed, 139 insertions(+), 151 deletions(-) delete mode 100644 utils/slither_format/format_unused_state.py rename utils/slither_format/{format_constable_states.py => formatters/constable_states.py} (61%) rename utils/slither_format/{format_constant_function.py => formatters/constant_function.py} (55%) rename utils/slither_format/{format_external_function.py => formatters/external_function.py} (61%) rename utils/slither_format/{format_naming_convention.py => formatters/naming_convention.py} (99%) rename utils/slither_format/{format_pragma.py => formatters/pragma.py} (72%) rename utils/slither_format/{format_solc_version.py => formatters/solc_version.py} (73%) create mode 100644 utils/slither_format/formatters/unused_state.py create mode 100644 utils/slither_format/utils/patches.py diff --git a/utils/slither_format/format_unused_state.py b/utils/slither_format/format_unused_state.py deleted file mode 100644 index 3fc40b19c..000000000 --- a/utils/slither_format/format_unused_state.py +++ /dev/null @@ -1,24 +0,0 @@ -class FormatUnusedState: - - @staticmethod - def format(slither, patches, elements): - for element in elements: - if element['type'] == "variable": - FormatUnusedState.create_patch(slither, patches, element['source_mapping']['filename_absolute'], \ - element['source_mapping']['filename_relative'], \ - element['source_mapping']['start']) - - @staticmethod - def create_patch(slither, patches, in_file, in_file_relative, modify_loc_start): - in_file_str = slither.source_code[in_file].encode('utf-8') - old_str_of_interest = in_file_str[modify_loc_start:] - patches[in_file_relative].append({ - "file" : in_file, - "detector" : "unused-state", - "start" : modify_loc_start, - "end" : modify_loc_start + len(old_str_of_interest.decode('utf-8').partition(';')[0]) + 1, - "old_string" : old_str_of_interest.decode('utf-8').partition(';')[0] + - old_str_of_interest.decode('utf-8').partition(';')[1], - "new_string" : "" - }) - diff --git a/utils/slither_format/format_constable_states.py b/utils/slither_format/formatters/constable_states.py similarity index 61% rename from utils/slither_format/format_constable_states.py rename to utils/slither_format/formatters/constable_states.py index ca0cf9cb2..2992964c6 100644 --- a/utils/slither_format/format_constable_states.py +++ b/utils/slither_format/formatters/constable_states.py @@ -1,9 +1,6 @@ -import re, logging, sys -from slither.utils.colors import red, yellow, set_colorization_enabled - -logging.basicConfig(level=logging.INFO) -logger = logging.getLogger('Slither.Format') -set_colorization_enabled(True) +import re +from slither.exceptions import SlitherException +from ..utils.patches import create_patch class FormatConstableStates: @@ -21,14 +18,17 @@ class FormatConstableStates: old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] (new_str_of_interest, num_repl) = re.subn(match_text, replace_text, old_str_of_interest.decode('utf-8'), 1) if num_repl != 0: - patches[in_file_relative].append({ - "file" : in_file, - "detector" : "constable-states", - "start" : modify_loc_start, - "end" : modify_loc_end, - "old_string" : old_str_of_interest.decode('utf-8'), - "new_string" : new_str_of_interest - }) + create_patch( + patches, + "constable-states", + in_file_relative, + in_file, + modify_loc_start, + modify_loc_end, + old_str_of_interest.decode('utf-8'), + new_str_of_interest + ) + else: - logger.error(red("State variable not found?!")) - sys.exit(-1) + raise SlitherException("State variable not found?!") + diff --git a/utils/slither_format/format_constant_function.py b/utils/slither_format/formatters/constant_function.py similarity index 55% rename from utils/slither_format/format_constant_function.py rename to utils/slither_format/formatters/constant_function.py index 936216f2b..9592579d4 100644 --- a/utils/slither_format/format_constant_function.py +++ b/utils/slither_format/formatters/constant_function.py @@ -1,9 +1,6 @@ -import re, logging -from slither.utils.colors import red, yellow, set_colorization_enabled - -logging.basicConfig(level=logging.INFO) -logger = logging.getLogger('Slither.Format') -set_colorization_enabled(True) +import re +from slither.exceptions import SlitherException +from ..utils.patches import create_patch class FormatConstantFunction: @@ -17,28 +14,26 @@ class FormatConstantFunction: if target_contract: for function in target_contract.functions: if function.name == element['name']: - FormatConstantFunction.create_patch(slither, patches, \ - element['source_mapping']['filename_absolute'], \ - element['source_mapping']['filename_relative'], \ - ["view","pure","constant"], "", \ - int(function.parameters_src.source_mapping['start']), \ + FormatConstantFunction.create_patch(slither, patches, + element['source_mapping']['filename_absolute'], + element['source_mapping']['filename_relative'], + int(function.parameters_src.source_mapping['start']), int(function.returns_src.source_mapping['start'])) break @staticmethod - def create_patch(slither, patches, in_file, in_file_relative, match_text, replace_text, modify_loc_start, modify_loc_end): + def create_patch(slither, patches, in_file, in_file_relative, modify_loc_start, modify_loc_end): in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] m = re.search("(view|pure|constant)", old_str_of_interest.decode('utf-8')) if m: - patches[in_file_relative].append({ - "file" : in_file, - "detector" : "constant-function", - "start" : modify_loc_start + m.span()[0], - "end" : modify_loc_start + m.span()[1], - "old_string" : m.groups(0)[0], - "new_string" : replace_text - }) + create_patch(patches, + "constant-function", + in_file_relative, + in_file, + modify_loc_start + m.span()[0], + modify_loc_start + m.span()[1], + m.groups(0)[0], + "") else: - logger.error(red("No view/pure/constant specifier exists. Regex failed to remove specifier!")) - sys.exit(-1) + raise SlitherException("No view/pure/constant specifier exists. Regex failed to remove specifier!") diff --git a/utils/slither_format/format_external_function.py b/utils/slither_format/formatters/external_function.py similarity index 61% rename from utils/slither_format/format_external_function.py rename to utils/slither_format/formatters/external_function.py index 21d4bce27..7bf124d49 100644 --- a/utils/slither_format/format_external_function.py +++ b/utils/slither_format/formatters/external_function.py @@ -1,9 +1,5 @@ -import re, logging -from slither.utils.colors import red, yellow, set_colorization_enabled - -logging.basicConfig(level=logging.INFO) -logger = logging.getLogger('Slither.Format') -set_colorization_enabled(True) +import re +from ..utils.patches import create_patch class FormatExternalFunction: @@ -18,38 +14,38 @@ class FormatExternalFunction: # to external because external function parameters are allocated in calldata region which is # non-modifiable. See https://solidity.readthedocs.io/en/develop/types.html#data-location if not FormatExternalFunction.function_parameters_written(function): - FormatExternalFunction.create_patch(slither, patches, \ - element['source_mapping']['filename_absolute'], \ - element['source_mapping']['filename_relative'], \ - "public", "external", \ - int(function.parameters_src.source_mapping['start']), \ + FormatExternalFunction.create_patch(slither, patches, + element['source_mapping']['filename_absolute'], + element['source_mapping']['filename_relative'], + "external", + int(function.parameters_src.source_mapping['start']), int(function.returns_src.source_mapping['start'])) break @staticmethod - def create_patch(slither, patches, in_file, in_file_relative, match_text, replace_text, modify_loc_start, modify_loc_end): + def create_patch(slither, patches, in_file, in_file_relative, replace_text, modify_loc_start, modify_loc_end): in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] m = re.search(r'((\spublic)\s+)|(\spublic)$|(\)public)$', old_str_of_interest.decode('utf-8')) if m is None: # No visibility specifier exists; public by default. - patches[in_file_relative].append({ - "file" : in_file, - "detector" : "external-function", - "start" : modify_loc_start + len(old_str_of_interest.decode('utf-8').split(')')[0]) + 1, - "end" : modify_loc_start + len(old_str_of_interest.decode('utf-8').split(')')[0]) + 1, - "old_string" : "", - "new_string" : " " + replace_text - }) + create_patch(patches, + "external-function", + in_file_relative, + in_file, + modify_loc_start + len(old_str_of_interest.decode('utf-8').split(')')[0]) + 1, + modify_loc_start + len(old_str_of_interest.decode('utf-8').split(')')[0]) + 1, + "", + " "+ replace_text) else: - patches[in_file_relative].append({ - "file" : in_file, - "detector" : "external-function", - "start" : modify_loc_start + m.span()[0] + 1, - "end" : modify_loc_start + m.span()[0] + 1 + 6, - "old_string" : match_text, - "new_string" : replace_text - }) + create_patch(patches, + "external-function", + in_file_relative, + in_file, + modify_loc_start + m.span()[0] + 1, + modify_loc_start + m.span()[0] + 1 + 6, + "", + " " + replace_text) @staticmethod def function_parameters_written(function): diff --git a/utils/slither_format/format_naming_convention.py b/utils/slither_format/formatters/naming_convention.py similarity index 99% rename from utils/slither_format/format_naming_convention.py rename to utils/slither_format/formatters/naming_convention.py index 2a902a314..9139a86d0 100644 --- a/utils/slither_format/format_naming_convention.py +++ b/utils/slither_format/formatters/naming_convention.py @@ -1,13 +1,11 @@ import re, sys, logging from slither.core.expressions.identifier import Identifier -from slither.core.cfg.node import Node from slither.slithir.operations import NewContract from slither.slithir.operations import Member -from slither.utils.colors import red, yellow, set_colorization_enabled +from slither.utils.colors import red logging.basicConfig(level=logging.INFO) logger = logging.getLogger('Slither.Format') -set_colorization_enabled(True) class FormatNamingConvention: diff --git a/utils/slither_format/format_pragma.py b/utils/slither_format/formatters/pragma.py similarity index 72% rename from utils/slither_format/format_pragma.py rename to utils/slither_format/formatters/pragma.py index db4dce905..d2c80dea3 100644 --- a/utils/slither_format/format_pragma.py +++ b/utils/slither_format/formatters/pragma.py @@ -1,9 +1,7 @@ -import re, logging, sys -from slither.utils.colors import red, yellow, set_colorization_enabled +import re +from slither.exceptions import SlitherException +from ..utils.patches import create_patch -logging.basicConfig(level=logging.INFO) -logger = logging.getLogger('Slither.Format') -set_colorization_enabled(True) class FormatPragma: @@ -25,10 +23,10 @@ class FormatPragma: versions_used.append(''.join(element['type_specific_fields']['directive'][1:])) solc_version_replace = FormatPragma.analyse_versions(versions_used) for element in elements: - FormatPragma.create_patch(slither, patches, element['source_mapping']['filename_absolute'], \ - element['source_mapping']['filename_relative'], solc_version_replace, \ - element['source_mapping']['start'], element['source_mapping']['start'] + \ - element['source_mapping']['length']) + FormatPragma.create_patch(slither, patches, element['source_mapping']['filename_absolute'], + element['source_mapping']['filename_relative'], solc_version_replace, + element['source_mapping']['start'], + element['source_mapping']['start'] + element['source_mapping']['length']) @staticmethod def analyse_versions(used_solc_versions): @@ -36,8 +34,7 @@ class FormatPragma: for version in used_solc_versions: replace_solc_versions.append(FormatPragma.determine_solc_version_replacement(version)) if not all(version == replace_solc_versions[0] for version in replace_solc_versions): - logger.error(red("Multiple incompatible versions!")) - sys.exit(-1) + raise SlitherException("Multiple incompatible versions!") else: return replace_solc_versions[0] @@ -52,27 +49,24 @@ class FormatPragma: elif minor_version == '5': return "pragma solidity " + FormatPragma.REPLACEMENT_VERSIONS[1] + ';' else: - logger.error(red("Unknown version!")) - sys.exit(-1) + raise SlitherException("Unknown version!") elif len(versions) == 2: - version_left = versions[0] version_right = versions[1] - minor_version_left = '.'.join(version_left[2:])[2] minor_version_right = '.'.join(version_right[2:])[2] if minor_version_right == '4': return "pragma solidity " + FormatPragma.REPLACEMENT_VERSIONS[0] + ';' - elif minor_version_right in ['5','6']: + elif minor_version_right in ['5', '6']: return "pragma solidity " + FormatPragma.REPLACEMENT_VERSIONS[1] + ';' - + @staticmethod def create_patch(slither, patches, in_file, in_file_relative, pragma, modify_loc_start, modify_loc_end): in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - patches[in_file_relative].append({ - "file" : in_file, - "detector" : "pragma", - "start" : modify_loc_start, - "end" : modify_loc_end, - "old_string" : old_str_of_interest.decode('utf-8'), - "new_string" : pragma - }) + create_patch(patches, + "pragma", + in_file_relative, + in_file, + int(modify_loc_start), + int(modify_loc_end), + old_str_of_interest.decode('utf-8'), + pragma) diff --git a/utils/slither_format/format_solc_version.py b/utils/slither_format/formatters/solc_version.py similarity index 73% rename from utils/slither_format/format_solc_version.py rename to utils/slither_format/formatters/solc_version.py index 6584020ee..48cb23c15 100644 --- a/utils/slither_format/format_solc_version.py +++ b/utils/slither_format/formatters/solc_version.py @@ -1,9 +1,6 @@ -import re, logging -from slither.utils.colors import red, yellow, set_colorization_enabled - -logging.basicConfig(level=logging.INFO) -logger = logging.getLogger('Slither.Format') -set_colorization_enabled(True) +import re +from slither.exceptions import SlitherException +from ..utils.patches import create_patch class FormatSolcVersion: @@ -23,8 +20,8 @@ class FormatSolcVersion: for element in elements: solc_version_replace = FormatSolcVersion.determine_solc_version_replacement( ''.join(element['type_specific_fields']['directive'][1:])) - FormatSolcVersion.create_patch(slither, patches, element['source_mapping']['filename_absolute'], \ - element['source_mapping']['filename_relative'], solc_version_replace, \ + FormatSolcVersion.create_patch(slither, patches, element['source_mapping']['filename_absolute'], + element['source_mapping']['filename_relative'], solc_version_replace, element['source_mapping']['start'], element['source_mapping']['start'] + element['source_mapping']['length']) @@ -39,12 +36,9 @@ class FormatSolcVersion: elif minor_version == '5': return "pragma solidity " + FormatSolcVersion.REPLACEMENT_VERSIONS[1] + ';' else: - logger.error(red("Unknown version!")) - sys.exit(-1) + raise SlitherException("Unknown version!") elif len(versions) == 2: - version_left = versions[0] version_right = versions[1] - minor_version_left = '.'.join(version_left[2:])[2] minor_version_right = '.'.join(version_right[2:])[2] if minor_version_right == '4': return "pragma solidity " + FormatSolcVersion.REPLACEMENT_VERSIONS[0] + ';' @@ -55,11 +49,11 @@ class FormatSolcVersion: def create_patch(slither, patches, in_file, in_file_relative, solc_version, modify_loc_start, modify_loc_end): in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - patches[in_file_relative].append({ - "file" : in_file, - "detector" : "solc-version", - "start" : modify_loc_start, - "end" : modify_loc_end, - "old_string" : old_str_of_interest.decode('utf-8'), - "new_string" : solc_version - }) + create_patch(patches, + "solc-version", + in_file_relative, + in_file, + int(modify_loc_start), + int(modify_loc_end), + old_str_of_interest.decode('utf-8'), + solc_version) diff --git a/utils/slither_format/formatters/unused_state.py b/utils/slither_format/formatters/unused_state.py new file mode 100644 index 000000000..a869afcc0 --- /dev/null +++ b/utils/slither_format/formatters/unused_state.py @@ -0,0 +1,29 @@ +from ..utils.patches import create_patch + +class FormatUnusedState: + + @staticmethod + def format(slither, patches, elements): + for element in elements: + if element['type'] == "variable": + FormatUnusedState.create_patch(slither, patches, + element['source_mapping']['filename_absolute'], + element['source_mapping']['filename_relative'], + element['source_mapping']['start']) + + @staticmethod + def create_patch(slither, patches, in_file, in_file_relative, modify_loc_start): + in_file_str = slither.source_code[in_file].encode('utf-8') + old_str_of_interest = in_file_str[modify_loc_start:] + old_str = old_str_of_interest.decode('utf-8').partition(';')[0]\ + + old_str_of_interest.decode('utf-8').partition(';')[1] + create_patch(patches, + "unused-state", + in_file_relative, + in_file, + int(modify_loc_start), + int(modify_loc_start + len(old_str_of_interest.decode('utf-8').partition(';')[0]) + 1), + old_str, + "") + + diff --git a/utils/slither_format/slither_format.py b/utils/slither_format/slither_format.py index aee4ce106..685fc40ca 100644 --- a/utils/slither_format/slither_format.py +++ b/utils/slither_format/slither_format.py @@ -1,6 +1,6 @@ -import sys, re, logging, subprocess +import sys, logging, subprocess from collections import defaultdict -from slither.utils.colors import red, yellow, set_colorization_enabled +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 @@ -8,17 +8,13 @@ from slither.detectors.naming_convention.naming_convention import NamingConventi 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 slither.slithir.operations import InternalCall -from slither.core.expressions.call_expression import CallExpression -from slither.core.expressions.expression import Expression -from slither.core.expressions.identifier import Identifier -from .format_unused_state import FormatUnusedState -from .format_solc_version import FormatSolcVersion -from .format_pragma import FormatPragma -from .format_naming_convention import FormatNamingConvention -from .format_external_function import FormatExternalFunction -from .format_constable_states import FormatConstableStates -from .format_constant_function import FormatConstantFunction +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') diff --git a/utils/slither_format/utils/patches.py b/utils/slither_format/utils/patches.py new file mode 100644 index 000000000..85ea85297 --- /dev/null +++ b/utils/slither_format/utils/patches.py @@ -0,0 +1,10 @@ + +def create_patch(patches, detector, file_relative, file, start, end, old_str, new_str): + patches[file_relative].append({ + "file": file, + "detector": detector, + "start": start, + "end": end, + "old_string": old_str, + "new_string": new_str + }) \ No newline at end of file From 7c51caf9983ea5b699010d603b8b8e67c2290731 Mon Sep 17 00:00:00 2001 From: Josselin Date: Mon, 24 Jun 2019 14:49:09 +0200 Subject: [PATCH 060/223] slither-format: remove objects pattern (Todo: naming convention) --- .../formatters/constable_states.py | 51 ++++---- .../formatters/constant_function.py | 63 +++++----- .../formatters/external_function.py | 87 ++++++------- .../formatters/naming_convention.py | 16 ++- utils/slither_format/formatters/pragma.py | 117 +++++++++--------- .../slither_format/formatters/solc_version.py | 99 +++++++-------- .../slither_format/formatters/unused_state.py | 45 ++++--- utils/slither_format/slither_format.py | 19 ++- 8 files changed, 235 insertions(+), 262 deletions(-) diff --git a/utils/slither_format/formatters/constable_states.py b/utils/slither_format/formatters/constable_states.py index 2992964c6..1d05432ad 100644 --- a/utils/slither_format/formatters/constable_states.py +++ b/utils/slither_format/formatters/constable_states.py @@ -2,33 +2,32 @@ import re from slither.exceptions import SlitherException from ..utils.patches import create_patch -class FormatConstableStates: +def format(slither, patches, elements): + for element in elements: + _patch(slither, patches, element['source_mapping']['filename_absolute'], + element['source_mapping']['filename_relative'], + element['name'], + "constant " + element['name'], + element['source_mapping']['start'], + element['source_mapping']['start'] + element['source_mapping']['length']) - @staticmethod - def format(slither, patches, elements): - for element in elements: - FormatConstableStates.create_patch(slither, patches, element['source_mapping']['filename_absolute'], \ - element['source_mapping']['filename_relative'], element['name'], \ - "constant " + element['name'], element['source_mapping']['start'], \ - element['source_mapping']['start'] + element['source_mapping']['length']) - @staticmethod - def create_patch(slither, patches, in_file, in_file_relative, match_text, replace_text, modify_loc_start, modify_loc_end): - in_file_str = slither.source_code[in_file].encode('utf-8') - old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - (new_str_of_interest, num_repl) = re.subn(match_text, replace_text, old_str_of_interest.decode('utf-8'), 1) - if num_repl != 0: - create_patch( - patches, - "constable-states", - in_file_relative, - in_file, - modify_loc_start, - modify_loc_end, - old_str_of_interest.decode('utf-8'), - new_str_of_interest - ) +def _patch(slither, patches, in_file, in_file_relative, match_text, replace_text, modify_loc_start, modify_loc_end): + in_file_str = slither.source_code[in_file].encode('utf-8') + old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + (new_str_of_interest, num_repl) = re.subn(match_text, replace_text, old_str_of_interest.decode('utf-8'), 1) + if num_repl != 0: + create_patch( + patches, + "constable-states", + in_file_relative, + in_file, + modify_loc_start, + modify_loc_end, + old_str_of_interest.decode('utf-8'), + new_str_of_interest + ) - else: - raise SlitherException("State variable not found?!") + else: + raise SlitherException("State variable not found?!") diff --git a/utils/slither_format/formatters/constant_function.py b/utils/slither_format/formatters/constant_function.py index 9592579d4..e6a6cec64 100644 --- a/utils/slither_format/formatters/constant_function.py +++ b/utils/slither_format/formatters/constant_function.py @@ -2,38 +2,35 @@ import re from slither.exceptions import SlitherException from ..utils.patches import create_patch -class FormatConstantFunction: +def format(slither, patches, elements): + for element in elements: + if element['type'] != "function": + # Skip variable elements + continue + target_contract = slither.get_contract_from_name(element['type_specific_fields']['parent']['name']) + if target_contract: + for function in target_contract.functions: + if function.name == element['name']: + _patch(slither, patches, + element['source_mapping']['filename_absolute'], + element['source_mapping']['filename_relative'], + int(function.parameters_src.source_mapping['start']), + int(function.returns_src.source_mapping['start'])) + break - @staticmethod - def format(slither, patches, elements): - for element in elements: - if element['type'] != "function": - # Skip variable elements - continue - target_contract = slither.get_contract_from_name(element['type_specific_fields']['parent']['name']) - if target_contract: - for function in target_contract.functions: - if function.name == element['name']: - FormatConstantFunction.create_patch(slither, patches, - element['source_mapping']['filename_absolute'], - element['source_mapping']['filename_relative'], - int(function.parameters_src.source_mapping['start']), - int(function.returns_src.source_mapping['start'])) - break - @staticmethod - def create_patch(slither, patches, in_file, in_file_relative, modify_loc_start, modify_loc_end): - in_file_str = slither.source_code[in_file].encode('utf-8') - old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - m = re.search("(view|pure|constant)", old_str_of_interest.decode('utf-8')) - if m: - create_patch(patches, - "constant-function", - in_file_relative, - in_file, - modify_loc_start + m.span()[0], - modify_loc_start + m.span()[1], - m.groups(0)[0], - "") - else: - raise SlitherException("No view/pure/constant specifier exists. Regex failed to remove specifier!") +def _patch(slither, patches, in_file, in_file_relative, modify_loc_start, modify_loc_end): + in_file_str = slither.source_code[in_file].encode('utf-8') + old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + m = re.search("(view|pure|constant)", old_str_of_interest.decode('utf-8')) + if m: + create_patch(patches, + "constant-function", + in_file_relative, + in_file, + modify_loc_start + m.span()[0], + modify_loc_start + m.span()[1], + m.groups(0)[0], + "") + else: + raise SlitherException("No view/pure/constant specifier exists. Regex failed to remove specifier!") diff --git a/utils/slither_format/formatters/external_function.py b/utils/slither_format/formatters/external_function.py index 7bf124d49..5e3a5fa45 100644 --- a/utils/slither_format/formatters/external_function.py +++ b/utils/slither_format/formatters/external_function.py @@ -1,56 +1,41 @@ import re from ..utils.patches import create_patch -class FormatExternalFunction: +def format(slither, patches, elements): + for element in elements: + target_contract = slither.get_contract_from_name(element['type_specific_fields']['parent']['name']) + if target_contract: + for function in target_contract.functions: + if function.name == element['name']: + _patch(slither, patches, + element['source_mapping']['filename_absolute'], + element['source_mapping']['filename_relative'], + "external", + int(function.parameters_src.source_mapping['start']), + int(function.returns_src.source_mapping['start'])) + break - @staticmethod - def format (slither, patches, elements): - for element in elements: - target_contract = slither.get_contract_from_name(element['type_specific_fields']['parent']['name']) - if target_contract: - for function in target_contract.functions: - if function.name == element['name']: - # If function parameters are written to in function body then we cannot convert this function - # to external because external function parameters are allocated in calldata region which is - # non-modifiable. See https://solidity.readthedocs.io/en/develop/types.html#data-location - if not FormatExternalFunction.function_parameters_written(function): - FormatExternalFunction.create_patch(slither, patches, - element['source_mapping']['filename_absolute'], - element['source_mapping']['filename_relative'], - "external", - int(function.parameters_src.source_mapping['start']), - int(function.returns_src.source_mapping['start'])) - break - @staticmethod - def create_patch(slither, patches, in_file, in_file_relative, replace_text, modify_loc_start, modify_loc_end): - in_file_str = slither.source_code[in_file].encode('utf-8') - old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - m = re.search(r'((\spublic)\s+)|(\spublic)$|(\)public)$', old_str_of_interest.decode('utf-8')) - if m is None: - # No visibility specifier exists; public by default. - create_patch(patches, - "external-function", - in_file_relative, - in_file, - modify_loc_start + len(old_str_of_interest.decode('utf-8').split(')')[0]) + 1, - modify_loc_start + len(old_str_of_interest.decode('utf-8').split(')')[0]) + 1, - "", - " "+ replace_text) - else: - create_patch(patches, - "external-function", - in_file_relative, - in_file, - modify_loc_start + m.span()[0] + 1, - modify_loc_start + m.span()[0] + 1 + 6, - "", - " " + replace_text) - - @staticmethod - def function_parameters_written(function): - for node in function.nodes: - if any (var.name == parameter.name for var in node.local_variables_written for parameter in function.parameters): - return True - return False - +def _patch(slither, patches, in_file, in_file_relative, replace_text, modify_loc_start, modify_loc_end): + in_file_str = slither.source_code[in_file].encode('utf-8') + old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + m = re.search(r'((\spublic)\s+)|(\spublic)$|(\)public)$', old_str_of_interest.decode('utf-8')) + if m is None: + # No visibility specifier exists; public by default. + create_patch(patches, + "external-function", + in_file_relative, + in_file, + modify_loc_start + len(old_str_of_interest.decode('utf-8').split(')')[0]) + 1, + modify_loc_start + len(old_str_of_interest.decode('utf-8').split(')')[0]) + 1, + "", + " "+ replace_text) + else: + create_patch(patches, + "external-function", + in_file_relative, + in_file, + modify_loc_start + m.span()[0] + 1, + modify_loc_start + m.span()[0] + 1 + 6, + "", + " " + replace_text) diff --git a/utils/slither_format/formatters/naming_convention.py b/utils/slither_format/formatters/naming_convention.py index 9139a86d0..f3d1dad02 100644 --- a/utils/slither_format/formatters/naming_convention.py +++ b/utils/slither_format/formatters/naming_convention.py @@ -13,13 +13,17 @@ class FormatNamingConvention: def format(slither, patches, elements): for element in elements: if (element['additional_fields']['target'] == "parameter"): - FormatNamingConvention.create_patch(slither, patches, element['additional_fields']['target'], \ - element['name'], element['type_specific_fields']['parent']['name'], \ + FormatNamingConvention.create_patch(slither, patches, + element['additional_fields']['target'], + element['name'], + element['type_specific_fields']['parent']['name'], element['type_specific_fields']['parent']['type_specific_fields'] - ['parent']['name'], element['source_mapping']['filename_absolute'], \ - element['source_mapping']['filename_relative'], \ - element['source_mapping']['start'],(element['source_mapping']['start'] + - element['source_mapping']['length'])) + ['parent']['name'], + element['source_mapping']['filename_absolute'], + element['source_mapping']['filename_relative'], + element['source_mapping']['start'], + (element['source_mapping']['start'] + + element['source_mapping']['length'])) elif (element['additional_fields']['target'] == "modifier" or element['additional_fields']['target'] == "function" or element['additional_fields']['target'] == "event" or diff --git a/utils/slither_format/formatters/pragma.py b/utils/slither_format/formatters/pragma.py index d2c80dea3..4efe0820d 100644 --- a/utils/slither_format/formatters/pragma.py +++ b/utils/slither_format/formatters/pragma.py @@ -2,71 +2,68 @@ import re from slither.exceptions import SlitherException from ..utils.patches import create_patch +# Indicates the recommended versions for replacement +REPLACEMENT_VERSIONS = ["0.4.25", "0.5.3"] -class FormatPragma: +# group: +# 0: ^ > >= < <= (optional) +# 1: ' ' (optional) +# 2: version number +# 3: version number +# 4: version number +PATTERN = re.compile('(\^|>|>=|<|<=)?([ ]+)?(\d+)\.(\d+)\.(\d+)') - # Indicates the recommended versions for replacement - REPLACEMENT_VERSIONS = ["0.4.25", "0.5.3"] - # group: - # 0: ^ > >= < <= (optional) - # 1: ' ' (optional) - # 2: version number - # 3: version number - # 4: version number - PATTERN = re.compile('(\^|>|>=|<|<=)?([ ]+)?(\d+)\.(\d+)\.(\d+)') +def format(slither, patches, elements): + versions_used = [] + for element in elements: + versions_used.append(''.join(element['type_specific_fields']['directive'][1:])) + solc_version_replace = _analyse_versions(versions_used) + for element in elements: + _patch(slither, patches, element['source_mapping']['filename_absolute'], + element['source_mapping']['filename_relative'], solc_version_replace, + element['source_mapping']['start'], + element['source_mapping']['start'] + element['source_mapping']['length']) - @staticmethod - def format(slither, patches, elements): - versions_used = [] - for element in elements: - versions_used.append(''.join(element['type_specific_fields']['directive'][1:])) - solc_version_replace = FormatPragma.analyse_versions(versions_used) - for element in elements: - FormatPragma.create_patch(slither, patches, element['source_mapping']['filename_absolute'], - element['source_mapping']['filename_relative'], solc_version_replace, - element['source_mapping']['start'], - element['source_mapping']['start'] + element['source_mapping']['length']) - @staticmethod - def analyse_versions(used_solc_versions): - replace_solc_versions = list() - for version in used_solc_versions: - replace_solc_versions.append(FormatPragma.determine_solc_version_replacement(version)) - if not all(version == replace_solc_versions[0] for version in replace_solc_versions): - raise SlitherException("Multiple incompatible versions!") +def _analyse_versions(used_solc_versions): + replace_solc_versions = list() + for version in used_solc_versions: + replace_solc_versions.append(_determine_solc_version_replacement(version)) + if not all(version == replace_solc_versions[0] for version in replace_solc_versions): + raise SlitherException("Multiple incompatible versions!") + else: + return replace_solc_versions[0] + + +def _determine_solc_version_replacement(used_solc_version): + versions = PATTERN.findall(used_solc_version) + if len(versions) == 1: + version = versions[0] + minor_version = '.'.join(version[2:])[2] + if minor_version == '4': + return "pragma solidity " + REPLACEMENT_VERSIONS[0] + ';' + elif minor_version == '5': + return "pragma solidity " + REPLACEMENT_VERSIONS[1] + ';' else: - return replace_solc_versions[0] + raise SlitherException("Unknown version!") + elif len(versions) == 2: + version_right = versions[1] + minor_version_right = '.'.join(version_right[2:])[2] + if minor_version_right == '4': + return "pragma solidity " + REPLACEMENT_VERSIONS[0] + ';' + elif minor_version_right in ['5', '6']: + return "pragma solidity " + REPLACEMENT_VERSIONS[1] + ';' - @staticmethod - def determine_solc_version_replacement(used_solc_version): - versions = FormatPragma.PATTERN.findall(used_solc_version) - if len(versions) == 1: - version = versions[0] - minor_version = '.'.join(version[2:])[2] - if minor_version == '4': - return "pragma solidity " + FormatPragma.REPLACEMENT_VERSIONS[0] + ';' - elif minor_version == '5': - return "pragma solidity " + FormatPragma.REPLACEMENT_VERSIONS[1] + ';' - else: - raise SlitherException("Unknown version!") - elif len(versions) == 2: - version_right = versions[1] - minor_version_right = '.'.join(version_right[2:])[2] - if minor_version_right == '4': - return "pragma solidity " + FormatPragma.REPLACEMENT_VERSIONS[0] + ';' - elif minor_version_right in ['5', '6']: - return "pragma solidity " + FormatPragma.REPLACEMENT_VERSIONS[1] + ';' - @staticmethod - def create_patch(slither, patches, in_file, in_file_relative, pragma, modify_loc_start, modify_loc_end): - in_file_str = slither.source_code[in_file].encode('utf-8') - old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - create_patch(patches, - "pragma", - in_file_relative, - in_file, - int(modify_loc_start), - int(modify_loc_end), - old_str_of_interest.decode('utf-8'), - pragma) +def _patch(slither, patches, in_file, in_file_relative, pragma, modify_loc_start, modify_loc_end): + in_file_str = slither.source_code[in_file].encode('utf-8') + old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + create_patch(patches, + "pragma", + in_file_relative, + in_file, + int(modify_loc_start), + int(modify_loc_end), + old_str_of_interest.decode('utf-8'), + pragma) diff --git a/utils/slither_format/formatters/solc_version.py b/utils/slither_format/formatters/solc_version.py index 48cb23c15..2e7ca33c1 100644 --- a/utils/slither_format/formatters/solc_version.py +++ b/utils/slither_format/formatters/solc_version.py @@ -2,58 +2,55 @@ import re from slither.exceptions import SlitherException from ..utils.patches import create_patch -class FormatSolcVersion: - # Indicates the recommended versions for replacement - REPLACEMENT_VERSIONS = ["0.4.25", "0.5.3"] +# Indicates the recommended versions for replacement +REPLACEMENT_VERSIONS = ["0.4.25", "0.5.3"] - # group: - # 0: ^ > >= < <= (optional) - # 1: ' ' (optional) - # 2: version number - # 3: version number - # 4: version number - PATTERN = re.compile('(\^|>|>=|<|<=)?([ ]+)?(\d+)\.(\d+)\.(\d+)') +# group: +# 0: ^ > >= < <= (optional) +# 1: ' ' (optional) +# 2: version number +# 3: version number +# 4: version number +PATTERN = re.compile('(\^|>|>=|<|<=)?([ ]+)?(\d+)\.(\d+)\.(\d+)') - @staticmethod - def format(slither, patches, elements): - for element in elements: - solc_version_replace = FormatSolcVersion.determine_solc_version_replacement( - ''.join(element['type_specific_fields']['directive'][1:])) - FormatSolcVersion.create_patch(slither, patches, element['source_mapping']['filename_absolute'], - element['source_mapping']['filename_relative'], solc_version_replace, - element['source_mapping']['start'], element['source_mapping']['start'] + - element['source_mapping']['length']) +def format(slither, patches, elements): + for element in elements: + solc_version_replace = _determine_solc_version_replacement( + ''.join(element['type_specific_fields']['directive'][1:])) + _patch(slither, patches, element['source_mapping']['filename_absolute'], + element['source_mapping']['filename_relative'], solc_version_replace, + element['source_mapping']['start'], element['source_mapping']['start'] + + element['source_mapping']['length']) - @staticmethod - def determine_solc_version_replacement(used_solc_version): - versions = FormatSolcVersion.PATTERN.findall(used_solc_version) - if len(versions) == 1: - version = versions[0] - minor_version = '.'.join(version[2:])[2] - if minor_version == '4': - return "pragma solidity " + FormatSolcVersion.REPLACEMENT_VERSIONS[0] + ';' - elif minor_version == '5': - return "pragma solidity " + FormatSolcVersion.REPLACEMENT_VERSIONS[1] + ';' - else: - raise SlitherException("Unknown version!") - elif len(versions) == 2: - version_right = versions[1] - minor_version_right = '.'.join(version_right[2:])[2] - if minor_version_right == '4': - return "pragma solidity " + FormatSolcVersion.REPLACEMENT_VERSIONS[0] + ';' - elif minor_version_right in ['5','6']: - return "pragma solidity " + FormatSolcVersion.REPLACEMENT_VERSIONS[1] + ';' - - @staticmethod - def create_patch(slither, patches, in_file, in_file_relative, solc_version, modify_loc_start, modify_loc_end): - in_file_str = slither.source_code[in_file].encode('utf-8') - old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - create_patch(patches, - "solc-version", - in_file_relative, - in_file, - int(modify_loc_start), - int(modify_loc_end), - old_str_of_interest.decode('utf-8'), - solc_version) +def _determine_solc_version_replacement(used_solc_version): + versions = PATTERN.findall(used_solc_version) + if len(versions) == 1: + version = versions[0] + minor_version = '.'.join(version[2:])[2] + if minor_version == '4': + return "pragma solidity " + REPLACEMENT_VERSIONS[0] + ';' + elif minor_version == '5': + return "pragma solidity " + REPLACEMENT_VERSIONS[1] + ';' + else: + raise SlitherException("Unknown version!") + elif len(versions) == 2: + version_right = versions[1] + minor_version_right = '.'.join(version_right[2:])[2] + if minor_version_right == '4': + return "pragma solidity " + REPLACEMENT_VERSIONS[0] + ';' + elif minor_version_right in ['5','6']: + return "pragma solidity " + REPLACEMENT_VERSIONS[1] + ';' + + +def _patch(slither, patches, in_file, in_file_relative, solc_version, modify_loc_start, modify_loc_end): + in_file_str = slither.source_code[in_file].encode('utf-8') + old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + create_patch(patches, + "solc-version", + in_file_relative, + in_file, + int(modify_loc_start), + int(modify_loc_end), + old_str_of_interest.decode('utf-8'), + solc_version) diff --git a/utils/slither_format/formatters/unused_state.py b/utils/slither_format/formatters/unused_state.py index a869afcc0..8f874c679 100644 --- a/utils/slither_format/formatters/unused_state.py +++ b/utils/slither_format/formatters/unused_state.py @@ -1,29 +1,28 @@ from ..utils.patches import create_patch -class FormatUnusedState: - @staticmethod - def format(slither, patches, elements): - for element in elements: - if element['type'] == "variable": - FormatUnusedState.create_patch(slither, patches, - element['source_mapping']['filename_absolute'], - element['source_mapping']['filename_relative'], - element['source_mapping']['start']) +def format(slither, patches, elements): + for element in elements: + if element['type'] == "variable": + _patch(slither, patches, + element['source_mapping']['filename_absolute'], + element['source_mapping']['filename_relative'], + element['source_mapping']['start']) - @staticmethod - def create_patch(slither, patches, in_file, in_file_relative, modify_loc_start): - in_file_str = slither.source_code[in_file].encode('utf-8') - old_str_of_interest = in_file_str[modify_loc_start:] - old_str = old_str_of_interest.decode('utf-8').partition(';')[0]\ - + old_str_of_interest.decode('utf-8').partition(';')[1] - create_patch(patches, - "unused-state", - in_file_relative, - in_file, - int(modify_loc_start), - int(modify_loc_start + len(old_str_of_interest.decode('utf-8').partition(';')[0]) + 1), - old_str, - "") + +def _patch(slither, patches, in_file, in_file_relative, modify_loc_start): + in_file_str = slither.source_code[in_file].encode('utf-8') + old_str_of_interest = in_file_str[modify_loc_start:] + old_str = old_str_of_interest.decode('utf-8').partition(';')[0]\ + + old_str_of_interest.decode('utf-8').partition(';')[1] + + create_patch(patches, + "unused-state", + in_file_relative, + in_file, + int(modify_loc_start), + int(modify_loc_start + len(old_str_of_interest.decode('utf-8').partition(';')[0]) + 1), + old_str, + "") diff --git a/utils/slither_format/slither_format.py b/utils/slither_format/slither_format.py index 685fc40ca..a3e663c18 100644 --- a/utils/slither_format/slither_format.py +++ b/utils/slither_format/slither_format.py @@ -8,13 +8,8 @@ from slither.detectors.naming_convention.naming_convention import NamingConventi 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 +from .formatters import unused_state, constable_states, pragma, solc_version, external_function logging.basicConfig(level=logging.INFO) logger = logging.getLogger('Slither.Format') @@ -178,19 +173,19 @@ def choose_detectors(args): def apply_detector_results(slither, patches, detector_results): for result in detector_results: if result['check'] == 'unused-state': - FormatUnusedState.format(slither, patches, result['elements']) + unused_state.format(slither, patches, result['elements']) elif result['check'] == 'solc-version': - FormatSolcVersion.format(slither, patches, result['elements']) + solc_version.format(slither, patches, result['elements']) elif result['check'] == 'pragma': - FormatPragma.format(slither, patches, result['elements']) + pragma.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']) + external_function.format(slither, patches, result['elements']) elif result['check'] == 'constable-states': - FormatConstableStates.format(slither, patches, result['elements']) + constable_states.format(slither, patches, result['elements']) elif result['check'] == 'constant-function': - FormatConstantFunction.format(slither, patches, result['elements']) + constable_states.format(slither, patches, result['elements']) else: logger.error(red("Not Supported Yet.")) sys.exit(-1) From aecd47c7d3197e6fd0be7c612ea5911ab42732ac Mon Sep 17 00:00:00 2001 From: Josselin Date: Tue, 25 Jun 2019 09:43:14 +0200 Subject: [PATCH 061/223] slither-format: refactor naming convention - Remove object - use namedtuple to improve code readability --- .../formatters/naming_convention.py | 1422 +++++++++-------- utils/slither_format/slither_format.py | 5 +- 2 files changed, 742 insertions(+), 685 deletions(-) diff --git a/utils/slither_format/formatters/naming_convention.py b/utils/slither_format/formatters/naming_convention.py index f3d1dad02..5c26cb6b1 100644 --- a/utils/slither_format/formatters/naming_convention.py +++ b/utils/slither_format/formatters/naming_convention.py @@ -1,744 +1,802 @@ -import re, sys, logging +import re +from collections import namedtuple +from slither.exceptions import SlitherException from slither.core.expressions.identifier import Identifier from slither.slithir.operations import NewContract from slither.slithir.operations import Member -from slither.utils.colors import red - -logging.basicConfig(level=logging.INFO) -logger = logging.getLogger('Slither.Format') - -class FormatNamingConvention: - - @staticmethod - def format(slither, patches, elements): - for element in elements: - if (element['additional_fields']['target'] == "parameter"): - FormatNamingConvention.create_patch(slither, patches, - element['additional_fields']['target'], - element['name'], - element['type_specific_fields']['parent']['name'], - element['type_specific_fields']['parent']['type_specific_fields'] - ['parent']['name'], - element['source_mapping']['filename_absolute'], - element['source_mapping']['filename_relative'], - element['source_mapping']['start'], - (element['source_mapping']['start'] + - element['source_mapping']['length'])) - elif (element['additional_fields']['target'] == "modifier" or - element['additional_fields']['target'] == "function" or - element['additional_fields']['target'] == "event" or - element['additional_fields']['target'] == "variable" or - element['additional_fields']['target'] == "variable_constant" or - element['additional_fields']['target'] == "enum" or - element['additional_fields']['target'] == "structure"): - FormatNamingConvention.create_patch(slither, patches, element['additional_fields']['target'], \ - element['name'], element['name'], \ - element['type_specific_fields']['parent']['name'], \ - element['source_mapping']['filename_absolute'], \ - element['source_mapping']['filename_relative'], \ - element['source_mapping']['start'],(element['source_mapping']['start'] + - element['source_mapping']['length'])) - else: - FormatNamingConvention.create_patch(slither, patches, element['additional_fields']['target'], \ - element['name'], element['name'], element['name'], \ - element['source_mapping']['filename_absolute'], \ - element['source_mapping']['filename_relative'], \ - element['source_mapping']['start'],(element['source_mapping']['start'] + - element['source_mapping']['length'])) - - @staticmethod - def create_patch(slither, patches, _target, name, function_name, contract_name, in_file, in_file_relative, - modify_loc_start, modify_loc_end): - if _target == "contract": - FormatNamingConvention.create_patch_contract_definition(slither, patches, name, in_file, in_file_relative, - modify_loc_start, modify_loc_end) - FormatNamingConvention.create_patch_contract_uses(slither, patches, name, in_file, in_file_relative) - elif _target == "structure": - FormatNamingConvention.create_patch_struct_definition(slither, patches, name, contract_name, in_file, - in_file_relative, modify_loc_start, modify_loc_end) - FormatNamingConvention.create_patch_struct_uses(slither, patches, name, contract_name, in_file, in_file_relative) - elif _target == "event": - FormatNamingConvention.create_patch_event_definition(slither, patches, name, contract_name, in_file, - in_file_relative, modify_loc_start, modify_loc_end) - FormatNamingConvention.create_patch_event_calls(slither, patches, name, contract_name, in_file, in_file_relative) - elif _target == "function": - if name != contract_name: - FormatNamingConvention.create_patch_function_definition(slither, patches, name, contract_name, in_file, - in_file_relative, modify_loc_start, modify_loc_end) - FormatNamingConvention.create_patch_function_calls(slither, patches, name, contract_name, in_file, - in_file_relative) - elif _target == "parameter": - FormatNamingConvention.create_patch_parameter_declaration(slither, patches, name, function_name, contract_name, - in_file, in_file_relative, modify_loc_start, - modify_loc_end) - FormatNamingConvention.create_patch_parameter_uses(slither, patches, name, function_name, contract_name, - in_file, in_file_relative) - elif _target == "variable_constant" or _target == "variable": - FormatNamingConvention.create_patch_state_variable_declaration(slither, patches, _target, name, contract_name, - in_file, in_file_relative, modify_loc_start, - modify_loc_end) - FormatNamingConvention.create_patch_state_variable_uses(slither, patches, _target, name, contract_name, in_file, - in_file_relative) - elif _target == "enum": - FormatNamingConvention.create_patch_enum_definition(slither, patches, name, contract_name, in_file, - in_file_relative, modify_loc_start, modify_loc_end) - FormatNamingConvention.create_patch_enum_uses(slither, patches, name, contract_name, in_file, in_file_relative) - elif _target == "modifier": - FormatNamingConvention.create_patch_modifier_definition(slither, patches, name, contract_name, in_file, - in_file_relative, modify_loc_start, modify_loc_end) - FormatNamingConvention.create_patch_modifier_uses(slither, patches, name, contract_name, in_file, - in_file_relative) + +# The Namedtuple will be used to give all the parameters from _patch to the _create_X functions +# Its used to improve code readability and avoid incorrect parameters order +FormatInfo = namedtuple("FormatInfo", ["slither", + "patches", + "target", + "name", + "function_name", + "contract_name", + "in_file", + "in_file_relative", + "loc_start", + "loc_end"]) + + +def format(slither, patches, elements): + for element in elements: + target = element['additional_fields']['target'] + if (target == "parameter"): + _patch(slither, patches, + element['additional_fields']['target'], + element['name'], + element['type_specific_fields']['parent']['name'], + element['type_specific_fields']['parent']['type_specific_fields']['parent']['name'], + element['source_mapping']['filename_absolute'], + element['source_mapping']['filename_relative'], + element['source_mapping']['start'], + (element['source_mapping']['start'] + element['source_mapping']['length'])) + + elif target in ["modifier", "function", "event", + "variable", "variable_constant", "enum" + "structure"]: + _patch(slither, patches, target, + element['name'], element['name'], + element['type_specific_fields']['parent']['name'], + element['source_mapping']['filename_absolute'], + element['source_mapping']['filename_relative'], + element['source_mapping']['start'], + (element['source_mapping']['start'] + element['source_mapping']['length'])) else: - logger.error(red("Unknown naming convention! " + _target)) - sys.exit(-1) + _patch(slither, patches, element['additional_fields']['target'], + element['name'], element['name'], element['name'], + element['source_mapping']['filename_absolute'], + element['source_mapping']['filename_relative'], + element['source_mapping']['start'], + (element['source_mapping']['start'] + element['source_mapping']['length'])) + + +def _patch(slither, patches, _target, name, function_name, contract_name, in_file, in_file_relative, + modify_loc_start, modify_loc_end): + + format_info = FormatInfo(slither, + patches, + _target, + name, + function_name, + contract_name, + in_file, + in_file_relative, + modify_loc_start, + modify_loc_end) + + if _target == "contract": + _create_patch_contract_definition(format_info) + + _create_patch_contract_uses(format_info) + elif _target == "structure": + _create_patch_struct_definition(format_info) + + _create_patch_struct_uses(format_info) + elif _target == "event": + _create_patch_event_definition(format_info) + + _create_patch_event_calls(format_info) + + elif _target == "function": + if name != contract_name: + _create_patch_function_definition(format_info) + + _create_patch_function_calls(format_info) + elif _target == "parameter": + _create_patch_parameter_declaration(format_info) + + _create_patch_parameter_uses(format_info) + + elif _target in ["variable_constant", "variable"]: + _create_patch_state_variable_declaration(format_info) + + _create_patch_state_variable_uses(format_info) + elif _target == "enum": + _create_patch_enum_definition(format_info) + _create_patch_enum_uses(format_info) + elif _target == "modifier": + _create_patch_modifier_definition(format_info) + _create_patch_modifier_uses(format_info) + else: + raise SlitherException("Unknown naming convention! " + _target) + + - @staticmethod - def create_patch_contract_definition(slither, patches, name, in_file, in_file_relative, modify_loc_start, modify_loc_end): - in_file_str = slither.source_code[in_file].encode('utf-8') - old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - m = re.match(r'(.*)'+"contract"+r'(.*)'+name, old_str_of_interest.decode('utf-8')) - old_str_of_interest = in_file_str[modify_loc_start:modify_loc_start+m.span()[1]] - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"contract"+r'(.*)'+name, r'\1'+"contract"+r'\2'+name.capitalize(), - old_str_of_interest.decode('utf-8'), 1) - if num_repl != 0: - patch = { - "file" : in_file, - "detector" : "naming-convention (contract definition)", - "start":modify_loc_start, - "end":modify_loc_start+m.span()[1], - "old_string":old_str_of_interest.decode('utf-8'), - "new_string":new_str_of_interest - } - if not patch in patches[in_file_relative]: - patches[in_file_relative].append(patch) - else: - logger.error(red("Could not find contract?!")) - sys.exit(-1) - - @staticmethod - def create_patch_contract_uses(slither, patches, name, in_file, in_file_relative): - for contract in slither.contracts: - # Ignore contract definition - if contract.name != name: - in_file_str = slither.source_code[in_file].encode('utf-8') - # Check state variables of contract type - # To-do: Deep-check aggregate types (struct and mapping) - svs = contract.variables - for sv in svs: - if (str(sv.type) == name): - old_str_of_interest = in_file_str[sv.source_mapping['start']:(sv.source_mapping['start'] + - sv.source_mapping['length'])] - (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(), - old_str_of_interest.decode('utf-8'), 1) + +def _create_patch_contract_definition(format_info): + in_file_str = format_info.slither.source_code[format_info.in_file].encode('utf-8') + old_str_of_interest = in_file_str[format_info.loc_start:format_info.loc_end] + m = re.match(r'(.*)'+"contract"+r'(.*)'+format_info.name, old_str_of_interest.decode('utf-8')) + old_str_of_interest = in_file_str[format_info.loc_start:format_info.loc_start+m.span()[1]] + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"contract"+r'(.*)'+format_info.name, + r'\1'+"contract"+r'\2'+format_info.name.capitalize(), + old_str_of_interest.decode('utf-8'), 1) + if num_repl != 0: + patch = { + "file" : format_info.in_file, + "detector" : "naming-convention (contract definition)", + "start": format_info.loc_start, + "end": format_info.loc_start+m.span()[1], + "old_string":old_str_of_interest.decode('utf-8'), + "new_string":new_str_of_interest + } + if not patch in format_info.patches[format_info.in_file_relative]: + format_info.patches[format_info.in_file_relative].append(patch) + else: + raise SlitherException("Could not find contract?!") + + +def _create_patch_contract_uses(format_info): + slither, patches, name = format_info.slither, format_info.patches, format_info.name + in_file, in_file_relative = format_info.in_file, format_info.in_file_relative + + for contract in slither.contracts: + # Ignore contract definition + if contract.name != name: + in_file_str = slither.source_code[in_file].encode('utf-8') + # Check state variables of contract type + # To-do: Deep-check aggregate types (struct and mapping) + svs = contract.variables + for sv in svs: + if (str(sv.type) == name): + old_str_of_interest = in_file_str[sv.source_mapping['start']:(sv.source_mapping['start'] + + sv.source_mapping['length'])] + (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(), + old_str_of_interest.decode('utf-8'), 1) + patch = { + "file" : in_file, + "detector" : "naming-convention (contract state variable)", + "start" : sv.source_mapping['start'], + "end" : sv.source_mapping['start'] + sv.source_mapping['length'], + "old_string" : old_str_of_interest.decode('utf-8'), + "new_string" : new_str_of_interest + } + if not patch in patches[in_file_relative]: + patches[in_file_relative].append(patch) + # Check function+modifier locals+parameters+returns + # To-do: Deep-check aggregate types (struct and mapping) + fms = contract.functions + contract.modifiers + for fm in fms: + for v in fm.variables: + if (str(v.type) == name): + old_str_of_interest = in_file_str[v.source_mapping['start']:(v.source_mapping['start'] + + v.source_mapping['length'])] + old_str_of_interest = old_str_of_interest.decode('utf-8').split('=')[0] + (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(),old_str_of_interest, 1) patch = { "file" : in_file, - "detector" : "naming-convention (contract state variable)", - "start" : sv.source_mapping['start'], - "end" : sv.source_mapping['start'] + sv.source_mapping['length'], + "detector" : "naming-convention (contract function variable)", + "start" : v.source_mapping['start'], + "end" : v.source_mapping['start'] + len(old_str_of_interest), + "old_string" : old_str_of_interest, + "new_string" : new_str_of_interest + } + if not patch in patches[in_file_relative]: + patches[in_file_relative].append(patch) + # Check "new" expressions for creation of contract objects + for function in contract.functions: + for node in function.nodes: + for ir in node.irs: + if isinstance(ir, NewContract) and ir.contract_name == name: + old_str_of_interest = in_file_str[node.source_mapping['start']:node.source_mapping['start'] + + node.source_mapping['length']] + m = re.search("new"+r'(.*)'+name, old_str_of_interest.decode('utf-8')) + old_str_of_interest = old_str_of_interest.decode('utf-8')[m.span()[0]:] + (new_str_of_interest, num_repl) = re.subn("new"+r'(.*)'+name, "new"+r'\1'+name[0].upper() + + name[1:], old_str_of_interest, 1) + if num_repl != 0: + patch = { + "file" : in_file, + "detector" : "naming-convention (contract new object)", + "start" : node.source_mapping['start'] + m.span()[0], + "end" : node.source_mapping['start'] + m.span()[1], + "old_string" : old_str_of_interest, + "new_string" : new_str_of_interest + } + if not patch in patches[in_file_relative]: + patches[in_file_relative].append(patch) + else: + raise SlitherException("Could not find new object?!") + + +def _create_patch_modifier_definition(format_info): + slither, patches, name = format_info.slither, format_info.patches, format_info.name + in_file, in_file_relative = format_info.in_file, format_info.in_file_relative + contract_name = format_info.contract_name + modify_loc_start, modify_loc_end = format_info.loc_start, format_info.loc_end + + target_contract = slither.get_contract_from_name(contract_name) + if not target_contract: + raise SlitherException("Contract not found?!") + for modifier in target_contract.modifiers: + if modifier.name == name: + in_file_str = slither.source_code[in_file].encode('utf-8') + old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + m = re.match(r'(.*)'+"modifier"+r'(.*)'+name, old_str_of_interest.decode('utf-8')) + old_str_of_interest = in_file_str[modify_loc_start:modify_loc_start+m.span()[1]] + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"modifier"+r'(.*)'+name, r'\1'+"modifier"+r'\2' + + name[0].lower()+name[1:], old_str_of_interest.decode('utf-8'), 1) + if num_repl != 0: + patch = { + "file" : in_file, + "detector" : "naming-convention (modifier definition)", + "start" : modify_loc_start, + "end" : modify_loc_start+m.span()[1], + "old_string" : old_str_of_interest.decode('utf-8'), + "new_string" : new_str_of_interest + } + if not patch in patches[in_file_relative]: + patches[in_file_relative].append(patch) + else: + raise SlitherException("Could not find modifier?!") + + +def _create_patch_modifier_uses(format_info): + slither, patches, name = format_info.slither, format_info.patches, format_info.name + in_file, in_file_relative = format_info.in_file, format_info.in_file_relative + contract_name = format_info.contract_name + + target_contract = slither.get_contract_from_name(contract_name) + if not target_contract: + raise SlitherException("Contract not found?!") + for contract in [target_contract] + target_contract.derived_contracts: + for function in contract.functions: + for m in function.modifiers: + if (m.name == name): + in_file_str = slither.source_code[in_file].encode('utf-8') + old_str_of_interest = in_file_str[int(function.parameters_src.source_mapping['start']): + int(function.returns_src.source_mapping['start'])] + (new_str_of_interest, num_repl) = re.subn(name, name[0].lower()+name[1:], + old_str_of_interest.decode('utf-8'),1) + if num_repl != 0: + patch = { + "file" : in_file, + "detector" : "naming-convention (modifier uses)", + "start" : int(function.parameters_src.source_mapping['start']), + "end" : int(function.returns_src.source_mapping['start']), "old_string" : old_str_of_interest.decode('utf-8'), "new_string" : new_str_of_interest } + if not patch in patches[in_file_relative]: + patches[in_file_relative].append(patch) + else: + raise SlitherException("Could not find modifier name?!") + + +def _create_patch_function_definition(format_info): + slither, patches, name = format_info.slither, format_info.patches, format_info.name + in_file, in_file_relative = format_info.in_file, format_info.in_file_relative + contract_name = format_info.contract_name + modify_loc_start, modify_loc_end = format_info.loc_start, format_info.loc_end + + target_contract = slither.get_contract_from_name(contract_name) + if not target_contract: + raise SlitherException("Contract not found?!") + for function in target_contract.functions: + if function.name == name: + in_file_str = slither.source_code[in_file].encode('utf-8') + old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + m = re.match(r'(.*)'+"function"+r'\s*'+name, old_str_of_interest.decode('utf-8')) + old_str_of_interest = in_file_str[modify_loc_start:modify_loc_start+m.span()[1]] + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"function"+r'(.*)'+name, r'\1'+"function"+r'\2'+ + name[0].lower()+name[1:], old_str_of_interest.decode('utf-8'), 1) + if num_repl != 0: + patch = { + "file" : in_file, + "detector" : "naming-convention (function definition)", + "start" : modify_loc_start, + "end" : modify_loc_start+m.span()[1], + "old_string" : old_str_of_interest.decode('utf-8'), + "new_string" : new_str_of_interest + } + if not patch in patches[in_file_relative]: + patches[in_file_relative].append(patch) + else: + raise SlitherException("Could not find function?!") + + +def _create_patch_function_calls(format_info): + slither, patches, name = format_info.slither, format_info.patches, format_info.name + in_file, in_file_relative = format_info.in_file, format_info.in_file_relative + contract_name = format_info.contract_name + + for contract in slither.contracts: + for function in contract.functions: + for node in function.nodes: + for high_level_call in node.high_level_calls: + if (high_level_call[0].name == contract_name and high_level_call[1].name == name): + for external_call in node.external_calls_as_expressions: + called_function = str(external_call.called).split('.')[-1] + if called_function == high_level_call[1].name: + in_file_str = slither.source_code[in_file].encode('utf-8') + old_str_of_interest = in_file_str[int(external_call.source_mapping['start']): + int(external_call.source_mapping['start']) + + int(external_call.source_mapping['length'])] + called_function_name = old_str_of_interest.decode('utf-8').split('.')[-1] + fixed_function_name = called_function_name[0].lower() + called_function_name[1:] + new_string = '.'.join(old_str_of_interest.decode('utf-8').split('.')[:-1]) + '.' + \ + fixed_function_name + patch = { + "file" : in_file, + "detector" : "naming-convention (function calls)", + "start" : external_call.source_mapping['start'], + "end" : int(external_call.source_mapping['start']) + + int(external_call.source_mapping['length']), + "old_string" : old_str_of_interest.decode('utf-8'), + "new_string" : new_string + } + if not patch in patches[in_file_relative]: + patches[in_file_relative].append(patch) + for internal_call in node.internal_calls_as_expressions: + if (str(internal_call.called) == name): + in_file_str = slither.source_code[in_file].encode('utf-8') + old_str_of_interest = in_file_str[int(internal_call.source_mapping['start']): + int(internal_call.source_mapping['start']) + + int(internal_call.source_mapping['length'])] + old_str_of_interest = old_str_of_interest.decode('utf-8').split('(')[0] + patch = { + "file" : in_file, + "detector" : "naming-convention (function calls)", + "start" : internal_call.source_mapping['start'], + "end" : int(internal_call.source_mapping['start']) + + int(internal_call.source_mapping['length']) - + len('('.join(in_file_str[int(internal_call.source_mapping['start']): + int(internal_call.source_mapping['start']) + + int(internal_call.source_mapping['length'])] \ + .decode('utf-8').split('(')[1:])) - 1, + "old_string" : old_str_of_interest, + "new_string" : old_str_of_interest[0].lower()+old_str_of_interest[1:] + } if not patch in patches[in_file_relative]: patches[in_file_relative].append(patch) - # Check function+modifier locals+parameters+returns - # To-do: Deep-check aggregate types (struct and mapping) - fms = contract.functions + contract.modifiers - for fm in fms: - for v in fm.variables: - if (str(v.type) == name): - old_str_of_interest = in_file_str[v.source_mapping['start']:(v.source_mapping['start'] + - v.source_mapping['length'])] - old_str_of_interest = old_str_of_interest.decode('utf-8').split('=')[0] - (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(),old_str_of_interest, 1) - patch = { - "file" : in_file, - "detector" : "naming-convention (contract function variable)", - "start" : v.source_mapping['start'], - "end" : v.source_mapping['start'] + len(old_str_of_interest), - "old_string" : old_str_of_interest, - "new_string" : new_str_of_interest - } - if not patch in patches[in_file_relative]: - patches[in_file_relative].append(patch) - # Check "new" expressions for creation of contract objects - for function in contract.functions: + + +def _create_patch_event_definition(format_info): + slither, patches, name = format_info.slither, format_info.patches, format_info.name + in_file, in_file_relative = format_info.in_file, format_info.in_file_relative + contract_name = format_info.contract_name + modify_loc_start, modify_loc_end = format_info.loc_start, format_info.loc_end + + target_contract = slither.get_contract_from_name(contract_name) + if not target_contract: + raise SlitherException("Contract not found?!") + for event in target_contract.events: + if event.name == name: + event_name = name.split('(')[0] + in_file_str = slither.source_code[in_file].encode('utf-8') + old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"event"+r'(.*)'+event_name, r'\1'+"event"+r'\2' + + event_name[0].capitalize()+event_name[1:], + old_str_of_interest.decode('utf-8'), 1) + if num_repl != 0: + patch = { + "file" : in_file, + "detector" : "naming-convention (event definition)", + "start" : modify_loc_start, + "end" : modify_loc_end, + "old_string" : old_str_of_interest.decode('utf-8'), + "new_string" : new_str_of_interest + } + if not patch in patches[in_file_relative]: + patches[in_file_relative].append(patch) + else: + raise SlitherException("Could not find event?!") + + +def _create_patch_event_calls(format_info): + slither, patches, name = format_info.slither, format_info.patches, format_info.name + in_file, in_file_relative = format_info.in_file, format_info.in_file_relative + contract_name = format_info.contract_name + + event_name = name.split('(')[0] + target_contract = slither.get_contract_from_name(contract_name) + if not target_contract: + raise SlitherException("Contract not found?!") + for contract in [target_contract] + target_contract.derived_contracts: + for function in contract.functions: + for node in function.nodes: + for call in node.internal_calls_as_expressions: + if (str(call.called) == event_name): + in_file_str = slither.source_code[in_file].encode('utf-8') + old_str_of_interest = in_file_str[int(call.source_mapping['start']): + int(call.source_mapping['start']) + + int(call.source_mapping['length'])] + patch = { + "file" : in_file, + "detector" : "naming-convention (event calls)", + "start" : call.source_mapping['start'], + "end" : int(call.source_mapping['start']) + int(call.source_mapping['length']), + "old_string" : old_str_of_interest.decode('utf-8'), + "new_string" : old_str_of_interest.decode('utf-8')[0].capitalize() + + old_str_of_interest.decode('utf-8')[1:] + } + if not patch in patches[in_file_relative]: + patches[in_file_relative].append(patch) + + +def _create_patch_parameter_declaration(format_info): + slither, patches, name = format_info.slither, format_info.patches, format_info.name + in_file, in_file_relative = format_info.in_file, format_info.in_file_relative + contract_name = format_info.contract_name + modify_loc_start, modify_loc_end = format_info.loc_start, format_info.loc_end + function_name = format_info.function_name + + target_contract = slither.get_contract_from_name(contract_name) + if not target_contract: + raise SlitherException("Contract not found?!") + for function in target_contract.functions: + if function.name == function_name: + in_file_str = slither.source_code[in_file].encode('utf-8') + old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + if(name[0] == '_'): + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+name[0]+name[1].upper() + + name[2:]+r'\2', old_str_of_interest.decode('utf-8'), 1) + else: + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+'_'+name[0].upper() + + name[1:]+r'\2', old_str_of_interest.decode('utf-8'), 1) + if num_repl != 0: + patch = { + "file" : in_file, + "detector" : "naming-convention (parameter declaration)", + "start" : modify_loc_start, + "end" : modify_loc_end, + "old_string" : old_str_of_interest.decode('utf-8'), + "new_string" : new_str_of_interest + } + if not patch in patches[in_file_relative]: + patches[in_file_relative].append(patch) + else: + raise SlitherException("Could not find parameter declaration?!") + + +def _create_patch_parameter_uses(format_info): + slither, patches, name = format_info.slither, format_info.patches, format_info.name + in_file, in_file_relative = format_info.in_file, format_info.in_file_relative + contract_name = format_info.contract_name + function_name = format_info.function_name + + for contract in slither.contracts: + if (contract.name == contract_name): + for function in contract.functions: + if (function.name == function_name): + in_file_str = slither.source_code[in_file].encode('utf-8') for node in function.nodes: - for ir in node.irs: - if isinstance(ir, NewContract) and ir.contract_name == name: - old_str_of_interest = in_file_str[node.source_mapping['start']:node.source_mapping['start'] + - node.source_mapping['length']] - m = re.search("new"+r'(.*)'+name, old_str_of_interest.decode('utf-8')) - old_str_of_interest = old_str_of_interest.decode('utf-8')[m.span()[0]:] - (new_str_of_interest, num_repl) = re.subn("new"+r'(.*)'+name, "new"+r'\1'+name[0].upper() + - name[1:], old_str_of_interest, 1) + vars = node._expression_vars_written + node._expression_vars_read + for v in vars: + if isinstance(v, Identifier) and str(v) == name and [str(lv) for lv in + (node._local_vars_read + + node._local_vars_written) + if str(lv) == name]: + modify_loc_start = int(v.source_mapping['start']) + modify_loc_end = int(v.source_mapping['start']) + int(v.source_mapping['length']) + old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + if(name[0] == '_'): + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', + r'\1'+name[0]+name[1].upper()+name[2:] + + r'\2', old_str_of_interest.decode('utf-8'), + 1) + else: + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+'_' + + name[0].upper()+name[1:]+r'\2', + old_str_of_interest.decode('utf-8'), 1) if num_repl != 0: patch = { "file" : in_file, - "detector" : "naming-convention (contract new object)", - "start" : node.source_mapping['start'] + m.span()[0], - "end" : node.source_mapping['start'] + m.span()[1], - "old_string" : old_str_of_interest, + "detector" : "naming-convention (parameter uses)", + "start" : modify_loc_start, + "end" : modify_loc_end, + "old_string" : old_str_of_interest.decode('utf-8'), "new_string" : new_str_of_interest } - if not patch in patches[in_file_relative]: + if not patch in patches[in_file_relative]: patches[in_file_relative].append(patch) else: - logger.error(red("Could not find new object?!")) - sys.exit(-1) - - @staticmethod - def create_patch_modifier_definition(slither, patches, name, contract_name, in_file, in_file_relative, modify_loc_start, - modify_loc_end): - target_contract = slither.get_contract_from_name(contract_name) - if not target_contract: - logger.error(red("Contract not found?!")) - sys.exit(-1) - for modifier in target_contract.modifiers: - if modifier.name == name: - in_file_str = slither.source_code[in_file].encode('utf-8') - old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - m = re.match(r'(.*)'+"modifier"+r'(.*)'+name, old_str_of_interest.decode('utf-8')) - old_str_of_interest = in_file_str[modify_loc_start:modify_loc_start+m.span()[1]] - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"modifier"+r'(.*)'+name, r'\1'+"modifier"+r'\2' + - name[0].lower()+name[1:], old_str_of_interest.decode('utf-8'), 1) - if num_repl != 0: - patch = { - "file" : in_file, - "detector" : "naming-convention (modifier definition)", - "start" : modify_loc_start, - "end" : modify_loc_start+m.span()[1], - "old_string" : old_str_of_interest.decode('utf-8'), - "new_string" : new_str_of_interest - } - if not patch in patches[in_file_relative]: - patches[in_file_relative].append(patch) - else: - logger.error(red("Could not find modifier?!")) - sys.exit(-1) - - @staticmethod - def create_patch_modifier_uses(slither, patches, name, contract_name, in_file, in_file_relative): - target_contract = slither.get_contract_from_name(contract_name) - if not target_contract: - logger.error(red("Contract not found?!")) - sys.exit(-1) - for contract in [target_contract] + target_contract.derived_contracts: - for function in contract.functions: - for m in function.modifiers: - if (m.name == name): - in_file_str = slither.source_code[in_file].encode('utf-8') - old_str_of_interest = in_file_str[int(function.parameters_src.source_mapping['start']): - int(function.returns_src.source_mapping['start'])] - (new_str_of_interest, num_repl) = re.subn(name, name[0].lower()+name[1:], - old_str_of_interest.decode('utf-8'),1) - if num_repl != 0: - patch = { - "file" : in_file, - "detector" : "naming-convention (modifier uses)", - "start" : int(function.parameters_src.source_mapping['start']), - "end" : int(function.returns_src.source_mapping['start']), - "old_string" : old_str_of_interest.decode('utf-8'), - "new_string" : new_str_of_interest - } - if not patch in patches[in_file_relative]: - patches[in_file_relative].append(patch) - else: - logger.error(red("Could not find modifier name?!")) - sys.exit(-1) - - @staticmethod - def create_patch_function_definition(slither, patches, name, contract_name, in_file, in_file_relative, modify_loc_start, - modify_loc_end): - target_contract = slither.get_contract_from_name(contract_name) - if not target_contract: - logger.error(red("Contract not found?!")) - sys.exit(-1) - for function in target_contract.functions: - if function.name == name: - in_file_str = slither.source_code[in_file].encode('utf-8') - old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - m = re.match(r'(.*)'+"function"+r'\s*'+name, old_str_of_interest.decode('utf-8')) - old_str_of_interest = in_file_str[modify_loc_start:modify_loc_start+m.span()[1]] - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"function"+r'(.*)'+name, r'\1'+"function"+r'\2'+ - name[0].lower()+name[1:], old_str_of_interest.decode('utf-8'), 1) - if num_repl != 0: - patch = { - "file" : in_file, - "detector" : "naming-convention (function definition)", - "start" : modify_loc_start, - "end" : modify_loc_start+m.span()[1], - "old_string" : old_str_of_interest.decode('utf-8'), - "new_string" : new_str_of_interest - } - if not patch in patches[in_file_relative]: - patches[in_file_relative].append(patch) - else: - logger.error(red("Could not find function?!")) - sys.exit(-1) - - @staticmethod - def create_patch_function_calls(slither, patches, name, contract_name, in_file, in_file_relative): - for contract in slither.contracts: - for function in contract.functions: - for node in function.nodes: - for high_level_call in node.high_level_calls: - if (high_level_call[0].name == contract_name and high_level_call[1].name == name): - for external_call in node.external_calls_as_expressions: - called_function = str(external_call.called).split('.')[-1] - if called_function == high_level_call[1].name: - in_file_str = slither.source_code[in_file].encode('utf-8') - old_str_of_interest = in_file_str[int(external_call.source_mapping['start']): - int(external_call.source_mapping['start']) + - int(external_call.source_mapping['length'])] - called_function_name = old_str_of_interest.decode('utf-8').split('.')[-1] - fixed_function_name = called_function_name[0].lower() + called_function_name[1:] - new_string = '.'.join(old_str_of_interest.decode('utf-8').split('.')[:-1]) + '.' + \ - fixed_function_name + raise SlitherException("Could not find parameter use?!") + + # Process function parameters passed to modifiers + for modifier in function._expression_modifiers: + for arg in modifier.arguments: + if str(arg) == name: + old_str_of_interest = in_file_str[modifier.source_mapping['start']: + modifier.source_mapping['start'] + + modifier.source_mapping['length']] + old_str_of_interest_beyond_modifier_name = old_str_of_interest.decode('utf-8')\ + .split('(')[1] + if(name[0] == '_'): + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+name[0]+ + name[1].upper()+name[2:]+r'\2', + old_str_of_interest_beyond_modifier_name, 1) + else: + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+'_'+ + name[0].upper()+name[1:]+r'\2', + old_str_of_interest_beyond_modifier_name, 1) + if num_repl != 0: patch = { "file" : in_file, - "detector" : "naming-convention (function calls)", - "start" : external_call.source_mapping['start'], - "end" : int(external_call.source_mapping['start']) + - int(external_call.source_mapping['length']), - "old_string" : old_str_of_interest.decode('utf-8'), - "new_string" : new_string + "detector" : "naming-convention (parameter uses)", + "start" : modifier.source_mapping['start'] + + len(old_str_of_interest.decode('utf-8').split('(')[0]) + 1, + "end" : modifier.source_mapping['start'] + modifier.source_mapping['length'], + "old_string" : old_str_of_interest_beyond_modifier_name, + "new_string" : new_str_of_interest } - if not patch in patches[in_file_relative]: + if not patch in patches[in_file_relative]: patches[in_file_relative].append(patch) - for internal_call in node.internal_calls_as_expressions: - if (str(internal_call.called) == name): - in_file_str = slither.source_code[in_file].encode('utf-8') - old_str_of_interest = in_file_str[int(internal_call.source_mapping['start']): - int(internal_call.source_mapping['start']) + - int(internal_call.source_mapping['length'])] - old_str_of_interest = old_str_of_interest.decode('utf-8').split('(')[0] - patch = { - "file" : in_file, - "detector" : "naming-convention (function calls)", - "start" : internal_call.source_mapping['start'], - "end" : int(internal_call.source_mapping['start']) + - int(internal_call.source_mapping['length']) - - len('('.join(in_file_str[int(internal_call.source_mapping['start']): - int(internal_call.source_mapping['start']) + - int(internal_call.source_mapping['length'])] \ - .decode('utf-8').split('(')[1:])) - 1, - "old_string" : old_str_of_interest, - "new_string" : old_str_of_interest[0].lower()+old_str_of_interest[1:] - } - if not patch in patches[in_file_relative]: - patches[in_file_relative].append(patch) - - @staticmethod - def create_patch_event_definition(slither, patches, name, contract_name, in_file, in_file_relative, modify_loc_start, - modify_loc_end): - target_contract = slither.get_contract_from_name(contract_name) - if not target_contract: - logger.error(red("Contract not found?!")) - sys.exit(-1) - for event in target_contract.events: - if event.name == name: - event_name = name.split('(')[0] - in_file_str = slither.source_code[in_file].encode('utf-8') - old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"event"+r'(.*)'+event_name, r'\1'+"event"+r'\2' + - event_name[0].capitalize()+event_name[1:], - old_str_of_interest.decode('utf-8'), 1) - if num_repl != 0: + else: + raise SlitherException("Could not find parameter use in modifier?!") + + +def _create_patch_state_variable_declaration(format_info): + slither, patches, name = format_info.slither, format_info.patches, format_info.name + in_file, in_file_relative = format_info.in_file, format_info.in_file_relative + contract_name = format_info.contract_name + modify_loc_start, modify_loc_end = format_info.loc_start, format_info.loc_end + _target = format_info.target + + for contract in slither.contracts: + if (contract.name == contract_name): + for var in contract.state_variables: + if (var.name == name): + in_file_str = slither.source_code[in_file].encode('utf-8') + old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + m = re.search(name, old_str_of_interest.decode('utf-8')) + if (_target == "variable_constant"): + new_string = old_str_of_interest.decode('utf-8')[m.span()[0]:m.span()[1]].upper() + else: + new_string = old_str_of_interest.decode('utf-8')[m.span()[0]:m.span()[1]] + new_string = new_string[0].lower()+new_string[1:] patch = { "file" : in_file, - "detector" : "naming-convention (event definition)", - "start" : modify_loc_start, - "end" : modify_loc_end, - "old_string" : old_str_of_interest.decode('utf-8'), - "new_string" : new_str_of_interest + "detector" : "naming-convention (state variable declaration)", + "start" : modify_loc_start+m.span()[0], + "end" : modify_loc_start+m.span()[1], + "old_string" : old_str_of_interest.decode('utf-8')[m.span()[0]:m.span()[1]], + "new_string" : new_string } - if not patch in patches[in_file_relative]: + if not patch in patches[in_file_relative]: patches[in_file_relative].append(patch) - else: - logger.error(red("Could not find event?!")) - sys.exit(-1) - - @staticmethod - def create_patch_event_calls(slither, patches, name, contract_name, in_file, in_file_relative): - event_name = name.split('(')[0] - target_contract = slither.get_contract_from_name(contract_name) - if not target_contract: - logger.error(red("Contract not found?!")) - sys.exit(-1) - for contract in [target_contract] + target_contract.derived_contracts: - for function in contract.functions: - for node in function.nodes: - for call in node.internal_calls_as_expressions: - if (str(call.called) == event_name): + + +def _create_patch_state_variable_uses(format_info): + slither, patches, name = format_info.slither, format_info.patches, format_info.name + in_file, in_file_relative = format_info.in_file, format_info.in_file_relative + contract_name = format_info.contract_name + _target = format_info.target + + # To-do: Check cross-contract state variable uses + for contract in slither.contracts: + if (contract.name == contract_name): + target_contract = contract + for contract in slither.contracts: + if (contract == target_contract or (contract in target_contract.derived_contracts)): + fms = contract.functions + contract.modifiers + for fm in fms: + for node in fm.nodes: + vars = node._expression_vars_written + node._expression_vars_read + for v in vars: + if isinstance(v, Identifier) and str(v) == name and [str(sv) for sv in + (node._state_vars_read + + node._state_vars_written) + if str(sv) == name]: + modify_loc_start = int(v.source_mapping['start']) + modify_loc_end = int(v.source_mapping['start']) + int(v.source_mapping['length']) in_file_str = slither.source_code[in_file].encode('utf-8') - old_str_of_interest = in_file_str[int(call.source_mapping['start']): - int(call.source_mapping['start']) + - int(call.source_mapping['length'])] + old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + if (_target == "variable_constant"): + new_str_of_interest = old_str_of_interest.decode('utf-8').upper() + else: + new_str_of_interest = old_str_of_interest.decode('utf-8') + new_str_of_interest = new_str_of_interest[0].lower()+new_str_of_interest[1:] patch = { "file" : in_file, - "detector" : "naming-convention (event calls)", - "start" : call.source_mapping['start'], - "end" : int(call.source_mapping['start']) + int(call.source_mapping['length']), + "detector" : "naming-convention (state variable uses)", + "start" : modify_loc_start, + "end" : modify_loc_end, "old_string" : old_str_of_interest.decode('utf-8'), - "new_string" : old_str_of_interest.decode('utf-8')[0].capitalize() + - old_str_of_interest.decode('utf-8')[1:] + "new_string" : new_str_of_interest } - if not patch in patches[in_file_relative]: + if not patch in patches[in_file_relative]: patches[in_file_relative].append(patch) - - @staticmethod - def create_patch_parameter_declaration(slither, patches, name, function_name, contract_name, in_file, in_file_relative, - modify_loc_start, modify_loc_end): - target_contract = slither.get_contract_from_name(contract_name) - if not target_contract: - logger.error(red("Contract not found?!")) - sys.exit(-1) - for function in target_contract.functions: - if function.name == function_name: - in_file_str = slither.source_code[in_file].encode('utf-8') - old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - if(name[0] == '_'): - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+name[0]+name[1].upper() + - name[2:]+r'\2', old_str_of_interest.decode('utf-8'), 1) - else: - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+'_'+name[0].upper() + - name[1:]+r'\2', old_str_of_interest.decode('utf-8'), 1) - if num_repl != 0: + + +def _create_patch_enum_definition(format_info): + slither, patches, name = format_info.slither, format_info.patches, format_info.name + in_file, in_file_relative = format_info.in_file, format_info.in_file_relative + contract_name = format_info.contract_name + modify_loc_start, modify_loc_end = format_info.loc_start, format_info.loc_end + + for contract in slither.contracts: + if (contract.name == contract_name): + for enum in contract.enums: + if (enum.name == name): + in_file_str = slither.source_code[in_file].encode('utf-8') + old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"enum"+r'(.*)'+name, r'\1'+"enum"+r'\2'+ + name[0].capitalize()+name[1:], + old_str_of_interest.decode('utf-8'), 1) + if num_repl != 0: + patch = { + "file" : in_file, + "detector" : "naming-convention (enum definition)", + "start" : modify_loc_start, + "end" : modify_loc_end, + "old_string" : old_str_of_interest.decode('utf-8'), + "new_string" : new_str_of_interest + } + if not patch in patches[in_file_relative]: + patches[in_file_relative].append(patch) + else: + raise SlitherException("Could not find enum?!") + + +def _create_patch_enum_uses(format_info): + slither, patches, name = format_info.slither, format_info.patches, format_info.name + in_file, in_file_relative = format_info.in_file, format_info.in_file_relative + contract_name = format_info.contract_name + + for contract in slither.contracts: + if (contract.name == contract_name): + target_contract = contract + for contract in slither.contracts: + if (contract == target_contract or (contract in target_contract.derived_contracts)): + in_file_str = slither.source_code[in_file].encode('utf-8') + # Check state variable declarations of enum type + # To-do: Deep-check aggregate types (struct and mapping) + svs = contract.variables + for sv in svs: + if (str(sv.type) == contract_name + "." + name): + old_str_of_interest = in_file_str[sv.source_mapping['start']:(sv.source_mapping['start']+ + sv.source_mapping['length'])] + (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(), + old_str_of_interest.decode('utf-8'), 1) patch = { "file" : in_file, - "detector" : "naming-convention (parameter declaration)", - "start" : modify_loc_start, - "end" : modify_loc_end, + "detector" : "naming-convention (enum use)", + "start" : sv.source_mapping['start'], + "end" : sv.source_mapping['start'] + sv.source_mapping['length'], "old_string" : old_str_of_interest.decode('utf-8'), "new_string" : new_str_of_interest } - if not patch in patches[in_file_relative]: + if not patch in patches[in_file_relative]: patches[in_file_relative].append(patch) - else: - logger.error(red("Could not find parameter declaration?!")) - sys.exit(-1) - - @staticmethod - def create_patch_parameter_uses(slither, patches, name, function_name, contract_name, in_file, in_file_relative): - for contract in slither.contracts: - if (contract.name == contract_name): - for function in contract.functions: - if (function.name == function_name): - in_file_str = slither.source_code[in_file].encode('utf-8') - for node in function.nodes: - vars = node._expression_vars_written + node._expression_vars_read - for v in vars: - if isinstance(v, Identifier) and str(v) == name and [str(lv) for lv in - (node._local_vars_read + - node._local_vars_written) - if str(lv) == name]: - modify_loc_start = int(v.source_mapping['start']) - modify_loc_end = int(v.source_mapping['start']) + int(v.source_mapping['length']) - old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - if(name[0] == '_'): - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', - r'\1'+name[0]+name[1].upper()+name[2:] + - r'\2', old_str_of_interest.decode('utf-8'), - 1) - else: - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+'_' + - name[0].upper()+name[1:]+r'\2', - old_str_of_interest.decode('utf-8'), 1) - if num_repl != 0: - patch = { - "file" : in_file, - "detector" : "naming-convention (parameter uses)", - "start" : modify_loc_start, - "end" : modify_loc_end, - "old_string" : old_str_of_interest.decode('utf-8'), - "new_string" : new_str_of_interest - } - if not patch in patches[in_file_relative]: - patches[in_file_relative].append(patch) - else: - logger.error(red("Could not find parameter use?!")) - sys.exit(-1) - - # Process function parameters passed to modifiers - for modifier in function._expression_modifiers: - for arg in modifier.arguments: - if str(arg) == name: - old_str_of_interest = in_file_str[modifier.source_mapping['start']: - modifier.source_mapping['start'] + - modifier.source_mapping['length']] - old_str_of_interest_beyond_modifier_name = old_str_of_interest.decode('utf-8')\ - .split('(')[1] - if(name[0] == '_'): - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+name[0]+ - name[1].upper()+name[2:]+r'\2', - old_str_of_interest_beyond_modifier_name, 1) - else: - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+'_'+ - name[0].upper()+name[1:]+r'\2', - old_str_of_interest_beyond_modifier_name, 1) - if num_repl != 0: - patch = { - "file" : in_file, - "detector" : "naming-convention (parameter uses)", - "start" : modifier.source_mapping['start'] + - len(old_str_of_interest.decode('utf-8').split('(')[0]) + 1, - "end" : modifier.source_mapping['start'] + modifier.source_mapping['length'], - "old_string" : old_str_of_interest_beyond_modifier_name, - "new_string" : new_str_of_interest - } - if not patch in patches[in_file_relative]: - patches[in_file_relative].append(patch) - else: - logger.error(red("Could not find parameter use in modifier?!")) - sys.exit(-1) - - @staticmethod - def create_patch_state_variable_declaration(slither, patches, _target, name, contract_name, in_file, in_file_relative, - modify_loc_start, modify_loc_end): - for contract in slither.contracts: - if (contract.name == contract_name): - for var in contract.state_variables: - if (var.name == name): - in_file_str = slither.source_code[in_file].encode('utf-8') - old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - m = re.search(name, old_str_of_interest.decode('utf-8')) - if (_target == "variable_constant"): - new_string = old_str_of_interest.decode('utf-8')[m.span()[0]:m.span()[1]].upper() - else: - new_string = old_str_of_interest.decode('utf-8')[m.span()[0]:m.span()[1]] - new_string = new_string[0].lower()+new_string[1:] + # Check function+modifier locals+parameters+returns + # To-do: Deep-check aggregate types (struct and mapping) + fms = contract.functions + contract.modifiers + for fm in fms: + # Enum declarations + for v in fm.variables: + if (str(v.type) == contract_name + "." + name): + old_str_of_interest = in_file_str[v.source_mapping['start']:(v.source_mapping['start']+ + v.source_mapping['length'])] + (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(), + old_str_of_interest.decode('utf-8'), 1) patch = { "file" : in_file, - "detector" : "naming-convention (state variable declaration)", - "start" : modify_loc_start+m.span()[0], - "end" : modify_loc_start+m.span()[1], - "old_string" : old_str_of_interest.decode('utf-8')[m.span()[0]:m.span()[1]], - "new_string" : new_string + "detector" : "naming-convention (enum use)", + "start" : v.source_mapping['start'], + "end" : v.source_mapping['start'] + v.source_mapping['length'], + "old_string" : old_str_of_interest.decode('utf-8'), + "new_string" : new_str_of_interest } - if not patch in patches[in_file_relative]: + if not patch in patches[in_file_relative]: patches[in_file_relative].append(patch) - - @staticmethod - def create_patch_state_variable_uses(slither, patches, _target, name, contract_name, in_file, in_file_relative): - # To-do: Check cross-contract state variable uses - for contract in slither.contracts: - if (contract.name == contract_name): - target_contract = contract - for contract in slither.contracts: - if (contract == target_contract or (contract in target_contract.derived_contracts)): - fms = contract.functions + contract.modifiers - for fm in fms: - for node in fm.nodes: - vars = node._expression_vars_written + node._expression_vars_read - for v in vars: - if isinstance(v, Identifier) and str(v) == name and [str(sv) for sv in - (node._state_vars_read + - node._state_vars_written) - if str(sv) == name]: - modify_loc_start = int(v.source_mapping['start']) - modify_loc_end = int(v.source_mapping['start']) + int(v.source_mapping['length']) - in_file_str = slither.source_code[in_file].encode('utf-8') - old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - if (_target == "variable_constant"): - new_str_of_interest = old_str_of_interest.decode('utf-8').upper() + # Capture enum uses such as "num = numbers.ONE;" + for function in contract.functions: + for node in function.nodes: + for ir in node.irs: + if isinstance(ir, Member): + if str(ir.variable_left) == name: + old_str_of_interest = in_file_str[node.source_mapping['start']: + (node.source_mapping['start']+ + node.source_mapping['length'])].decode('utf-8')\ + .split('=')[1] + m = re.search(r'(.*)'+name, old_str_of_interest) + old_str_of_interest = old_str_of_interest[m.span()[0]:] + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name, r'\1'+name[0].upper()+name[1:], + old_str_of_interest, 1) + if num_repl != 0: + patch = { + "file" : in_file, + "detector" : "naming-convention (enum use)", + "start" : node.source_mapping['start'] + + len(in_file_str[node.source_mapping['start']: + (node.source_mapping['start']+ + node.source_mapping['length'])].decode('utf-8').split('=')[0]) + + 1 + m.span()[0], + "end" : node.source_mapping['start'] + + len(in_file_str[node.source_mapping['start']:(node.source_mapping['start']+ + node.source_mapping['length'])].\ + decode('utf-8').split('=')[0]) + 1 + m.span()[0] + len(old_str_of_interest), + "old_string" : old_str_of_interest, + "new_string" : new_str_of_interest + } + if not patch in patches[in_file_relative]: + patches[in_file_relative].append(patch) else: - new_str_of_interest = old_str_of_interest.decode('utf-8') - new_str_of_interest = new_str_of_interest[0].lower()+new_str_of_interest[1:] - patch = { - "file" : in_file, - "detector" : "naming-convention (state variable uses)", - "start" : modify_loc_start, - "end" : modify_loc_end, - "old_string" : old_str_of_interest.decode('utf-8'), - "new_string" : new_str_of_interest - } - if not patch in patches[in_file_relative]: - patches[in_file_relative].append(patch) + raise SlitherException("Could not find new object?!") + # To-do: Check any other place/way where enum type is used - @staticmethod - def create_patch_enum_definition(slither, patches, name, contract_name, in_file, in_file_relative, modify_loc_start, - modify_loc_end): - for contract in slither.contracts: - if (contract.name == contract_name): - for enum in contract.enums: - if (enum.name == name): - in_file_str = slither.source_code[in_file].encode('utf-8') - old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"enum"+r'(.*)'+name, r'\1'+"enum"+r'\2'+ - name[0].capitalize()+name[1:], - old_str_of_interest.decode('utf-8'), 1) - if num_repl != 0: - patch = { - "file" : in_file, - "detector" : "naming-convention (enum definition)", - "start" : modify_loc_start, - "end" : modify_loc_end, - "old_string" : old_str_of_interest.decode('utf-8'), - "new_string" : new_str_of_interest - } - if not patch in patches[in_file_relative]: - patches[in_file_relative].append(patch) - else: - logger.error(red("Could not find enum?!")) - sys.exit(-1) - - @staticmethod - def create_patch_enum_uses(slither, patches, name, contract_name, in_file, in_file_relative): - for contract in slither.contracts: - if (contract.name == contract_name): - target_contract = contract - for contract in slither.contracts: - if (contract == target_contract or (contract in target_contract.derived_contracts)): - in_file_str = slither.source_code[in_file].encode('utf-8') - # Check state variable declarations of enum type - # To-do: Deep-check aggregate types (struct and mapping) - svs = contract.variables - for sv in svs: - if (str(sv.type) == contract_name + "." + name): - old_str_of_interest = in_file_str[sv.source_mapping['start']:(sv.source_mapping['start']+ - sv.source_mapping['length'])] - (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(), - old_str_of_interest.decode('utf-8'), 1) + +def _create_patch_struct_definition(format_info): + slither, patches, name = format_info.slither, format_info.patches, format_info.name + in_file, in_file_relative = format_info.in_file, format_info.in_file_relative + contract_name = format_info.contract_name + modify_loc_start, modify_loc_end = format_info.loc_start, format_info.loc_end + + for contract in slither.contracts: + if (contract.name == contract_name): + for struct in contract.structures: + if (struct.name == name): + in_file_str = slither.source_code[in_file].encode('utf-8') + old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"struct"+r'(.*)'+name, r'\1'+"struct"+r'\2'+ + name[0].capitalize()+name[1:], + old_str_of_interest.decode('utf-8'), 1) + if num_repl != 0: patch = { "file" : in_file, - "detector" : "naming-convention (enum use)", - "start" : sv.source_mapping['start'], - "end" : sv.source_mapping['start'] + sv.source_mapping['length'], + "detector" : "naming-convention (struct definition)", + "start" : modify_loc_start, + "end" : modify_loc_end, "old_string" : old_str_of_interest.decode('utf-8'), "new_string" : new_str_of_interest } - if not patch in patches[in_file_relative]: + if not patch in patches[in_file_relative]: patches[in_file_relative].append(patch) - # Check function+modifier locals+parameters+returns - # To-do: Deep-check aggregate types (struct and mapping) - fms = contract.functions + contract.modifiers - for fm in fms: - # Enum declarations - for v in fm.variables: - if (str(v.type) == contract_name + "." + name): - old_str_of_interest = in_file_str[v.source_mapping['start']:(v.source_mapping['start']+ - v.source_mapping['length'])] - (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(), - old_str_of_interest.decode('utf-8'), 1) - patch = { - "file" : in_file, - "detector" : "naming-convention (enum use)", - "start" : v.source_mapping['start'], - "end" : v.source_mapping['start'] + v.source_mapping['length'], - "old_string" : old_str_of_interest.decode('utf-8'), - "new_string" : new_str_of_interest - } - if not patch in patches[in_file_relative]: - patches[in_file_relative].append(patch) - # Capture enum uses such as "num = numbers.ONE;" - for function in contract.functions: - for node in function.nodes: - for ir in node.irs: - if isinstance(ir, Member): - if str(ir.variable_left) == name: - old_str_of_interest = in_file_str[node.source_mapping['start']: - (node.source_mapping['start']+ - node.source_mapping['length'])].decode('utf-8')\ - .split('=')[1] - m = re.search(r'(.*)'+name, old_str_of_interest) - old_str_of_interest = old_str_of_interest[m.span()[0]:] - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name, r'\1'+name[0].upper()+name[1:], - old_str_of_interest, 1) - if num_repl != 0: - patch = { - "file" : in_file, - "detector" : "naming-convention (enum use)", - "start" : node.source_mapping['start'] + - len(in_file_str[node.source_mapping['start']: - (node.source_mapping['start']+ - node.source_mapping['length'])].decode('utf-8').split('=')[0]) + - 1 + m.span()[0], - "end" : node.source_mapping['start'] + - len(in_file_str[node.source_mapping['start']:(node.source_mapping['start']+ - node.source_mapping['length'])].\ - decode('utf-8').split('=')[0]) + 1 + m.span()[0] + len(old_str_of_interest), - "old_string" : old_str_of_interest, - "new_string" : new_str_of_interest - } - if not patch in patches[in_file_relative]: - patches[in_file_relative].append(patch) - else: - logger.error(red("Could not find new object?!")) - sys.exit(-1) - # To-do: Check any other place/way where enum type is used - - @staticmethod - def create_patch_struct_definition(slither, patches, name, contract_name, in_file, in_file_relative, modify_loc_start, - modify_loc_end): - for contract in slither.contracts: - if (contract.name == contract_name): - for struct in contract.structures: - if (struct.name == name): - in_file_str = slither.source_code[in_file].encode('utf-8') - old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"struct"+r'(.*)'+name, r'\1'+"struct"+r'\2'+ - name[0].capitalize()+name[1:], - old_str_of_interest.decode('utf-8'), 1) - if num_repl != 0: - patch = { - "file" : in_file, - "detector" : "naming-convention (struct definition)", - "start" : modify_loc_start, - "end" : modify_loc_end, - "old_string" : old_str_of_interest.decode('utf-8'), - "new_string" : new_str_of_interest - } - if not patch in patches[in_file_relative]: - patches[in_file_relative].append(patch) - else: - logger.error(red("Could not find struct?!")) - sys.exit(-1) - - @staticmethod - def create_patch_struct_uses(slither, patches, name, contract_name, in_file, in_file_relative): - for contract in slither.contracts: - if (contract.name == contract_name): - target_contract = contract - for contract in slither.contracts: - if (contract == target_contract or (contract in target_contract.derived_contracts)): - in_file_str = slither.source_code[in_file].encode('utf-8') - # Check state variables of struct type - # To-do: Deep-check aggregate types (struct and mapping) - svs = contract.variables - for sv in svs: - if (str(sv.type) == contract_name + "." + name): - old_str_of_interest = in_file_str[sv.source_mapping['start']:(sv.source_mapping['start']+ - sv.source_mapping['length'])] + else: + raise SlitherException("Could not find struct?!") + + +def _create_patch_struct_uses(format_info): + slither, patches, name = format_info.slither, format_info.patches, format_info.name + in_file, in_file_relative = format_info.in_file, format_info.in_file_relative + contract_name = format_info.contract_name + + for contract in slither.contracts: + if (contract.name == contract_name): + target_contract = contract + for contract in slither.contracts: + if (contract == target_contract or (contract in target_contract.derived_contracts)): + in_file_str = slither.source_code[in_file].encode('utf-8') + # Check state variables of struct type + # To-do: Deep-check aggregate types (struct and mapping) + svs = contract.variables + for sv in svs: + if (str(sv.type) == contract_name + "." + name): + old_str_of_interest = in_file_str[sv.source_mapping['start']:(sv.source_mapping['start']+ + sv.source_mapping['length'])] + (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(), + old_str_of_interest.decode('utf-8'), 1) + patch = { + "file" : in_file, + "detector" : "naming-convention (struct use)", + "start" : sv.source_mapping['start'], + "end" : sv.source_mapping['start'] + sv.source_mapping['length'], + "old_string" : old_str_of_interest.decode('utf-8'), + "new_string" : new_str_of_interest + } + if not patch in patches[in_file_relative]: + patches[in_file_relative].append(patch) + # Check function+modifier locals+parameters+returns + # To-do: Deep-check aggregate types (struct and mapping) + fms = contract.functions + contract.modifiers + for fm in fms: + for v in fm.variables: + if (str(v.type) == contract_name + "." + name): + old_str_of_interest = in_file_str[v.source_mapping['start']:(v.source_mapping['start']+ + v.source_mapping['length'])] (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(), old_str_of_interest.decode('utf-8'), 1) patch = { "file" : in_file, "detector" : "naming-convention (struct use)", - "start" : sv.source_mapping['start'], - "end" : sv.source_mapping['start'] + sv.source_mapping['length'], + "start" : v.source_mapping['start'], + "end" : v.source_mapping['start'] + v.source_mapping['length'], "old_string" : old_str_of_interest.decode('utf-8'), "new_string" : new_str_of_interest } if not patch in patches[in_file_relative]: patches[in_file_relative].append(patch) - # Check function+modifier locals+parameters+returns - # To-do: Deep-check aggregate types (struct and mapping) - fms = contract.functions + contract.modifiers - for fm in fms: - for v in fm.variables: - if (str(v.type) == contract_name + "." + name): - old_str_of_interest = in_file_str[v.source_mapping['start']:(v.source_mapping['start']+ - v.source_mapping['length'])] - (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(), - old_str_of_interest.decode('utf-8'), 1) - patch = { - "file" : in_file, - "detector" : "naming-convention (struct use)", - "start" : v.source_mapping['start'], - "end" : v.source_mapping['start'] + v.source_mapping['length'], - "old_string" : old_str_of_interest.decode('utf-8'), - "new_string" : new_str_of_interest - } - if not patch in patches[in_file_relative]: - patches[in_file_relative].append(patch) - # To-do: Check any other place/way where struct type is used (e.g. typecast) + # To-do: Check any other place/way where struct type is used (e.g. typecast) diff --git a/utils/slither_format/slither_format.py b/utils/slither_format/slither_format.py index a3e663c18..7ca9db962 100644 --- a/utils/slither_format/slither_format.py +++ b/utils/slither_format/slither_format.py @@ -8,8 +8,7 @@ from slither.detectors.naming_convention.naming_convention import NamingConventi 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.naming_convention import FormatNamingConvention -from .formatters import unused_state, constable_states, pragma, solc_version, external_function +from .formatters import unused_state, constable_states, pragma, solc_version, external_function, naming_convention logging.basicConfig(level=logging.INFO) logger = logging.getLogger('Slither.Format') @@ -179,7 +178,7 @@ def apply_detector_results(slither, patches, detector_results): elif result['check'] == 'pragma': pragma.format(slither, patches, result['elements']) elif result['check'] == 'naming-convention': - FormatNamingConvention.format(slither, patches, result['elements']) + naming_convention.format(slither, patches, result['elements']) elif result['check'] == 'external-function': external_function.format(slither, patches, result['elements']) elif result['check'] == 'constable-states': From 7f8289aad0d4668759453a6ccc67310858dc1760 Mon Sep 17 00:00:00 2001 From: Josselin Date: Tue, 25 Jun 2019 10:00:02 +0200 Subject: [PATCH 062/223] slither-format: simplify loop iteration on contracts --- .../formatters/naming_convention.py | 582 +++++++++--------- 1 file changed, 303 insertions(+), 279 deletions(-) diff --git a/utils/slither_format/formatters/naming_convention.py b/utils/slither_format/formatters/naming_convention.py index 5c26cb6b1..6580e03b6 100644 --- a/utils/slither_format/formatters/naming_convention.py +++ b/utils/slither_format/formatters/naming_convention.py @@ -23,7 +23,8 @@ def format(slither, patches, elements): for element in elements: target = element['additional_fields']['target'] if (target == "parameter"): - _patch(slither, patches, + _patch(slither, + patches, element['additional_fields']['target'], element['name'], element['type_specific_fields']['parent']['name'], @@ -36,16 +37,23 @@ def format(slither, patches, elements): elif target in ["modifier", "function", "event", "variable", "variable_constant", "enum" "structure"]: - _patch(slither, patches, target, - element['name'], element['name'], + _patch(slither, + patches, + target, + element['name'], + element['name'], element['type_specific_fields']['parent']['name'], element['source_mapping']['filename_absolute'], element['source_mapping']['filename_relative'], element['source_mapping']['start'], (element['source_mapping']['start'] + element['source_mapping']['length'])) else: - _patch(slither, patches, element['additional_fields']['target'], - element['name'], element['name'], element['name'], + _patch(slither, + patches, + element['additional_fields']['target'], + element['name'], + element['name'], + element['name'], element['source_mapping']['filename_absolute'], element['source_mapping']['filename_relative'], element['source_mapping']['start'], @@ -457,75 +465,74 @@ def _create_patch_parameter_uses(format_info): contract_name = format_info.contract_name function_name = format_info.function_name - for contract in slither.contracts: - if (contract.name == contract_name): - for function in contract.functions: - if (function.name == function_name): - in_file_str = slither.source_code[in_file].encode('utf-8') - for node in function.nodes: - vars = node._expression_vars_written + node._expression_vars_read - for v in vars: - if isinstance(v, Identifier) and str(v) == name and [str(lv) for lv in - (node._local_vars_read + - node._local_vars_written) - if str(lv) == name]: - modify_loc_start = int(v.source_mapping['start']) - modify_loc_end = int(v.source_mapping['start']) + int(v.source_mapping['length']) - old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - if(name[0] == '_'): - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', - r'\1'+name[0]+name[1].upper()+name[2:] + - r'\2', old_str_of_interest.decode('utf-8'), - 1) - else: - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+'_' + - name[0].upper()+name[1:]+r'\2', - old_str_of_interest.decode('utf-8'), 1) - if num_repl != 0: - patch = { - "file" : in_file, - "detector" : "naming-convention (parameter uses)", - "start" : modify_loc_start, - "end" : modify_loc_end, - "old_string" : old_str_of_interest.decode('utf-8'), - "new_string" : new_str_of_interest - } - if not patch in patches[in_file_relative]: - patches[in_file_relative].append(patch) - else: - raise SlitherException("Could not find parameter use?!") - - # Process function parameters passed to modifiers - for modifier in function._expression_modifiers: - for arg in modifier.arguments: - if str(arg) == name: - old_str_of_interest = in_file_str[modifier.source_mapping['start']: - modifier.source_mapping['start'] + - modifier.source_mapping['length']] - old_str_of_interest_beyond_modifier_name = old_str_of_interest.decode('utf-8')\ - .split('(')[1] - if(name[0] == '_'): - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+name[0]+ - name[1].upper()+name[2:]+r'\2', - old_str_of_interest_beyond_modifier_name, 1) - else: - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+'_'+ - name[0].upper()+name[1:]+r'\2', - old_str_of_interest_beyond_modifier_name, 1) - if num_repl != 0: - patch = { - "file" : in_file, - "detector" : "naming-convention (parameter uses)", - "start" : modifier.source_mapping['start'] + - len(old_str_of_interest.decode('utf-8').split('(')[0]) + 1, - "end" : modifier.source_mapping['start'] + modifier.source_mapping['length'], - "old_string" : old_str_of_interest_beyond_modifier_name, - "new_string" : new_str_of_interest - } - if not patch in patches[in_file_relative]: - patches[in_file_relative].append(patch) - else: - raise SlitherException("Could not find parameter use in modifier?!") + target_contract = slither.get_contract_from_name(contract_name) + for function in target_contract.functions: + if (function.name == function_name): + in_file_str = slither.source_code[in_file].encode('utf-8') + for node in function.nodes: + vars = node._expression_vars_written + node._expression_vars_read + for v in vars: + if isinstance(v, Identifier) and str(v) == name and [str(lv) for lv in + (node._local_vars_read + + node._local_vars_written) + if str(lv) == name]: + modify_loc_start = int(v.source_mapping['start']) + modify_loc_end = int(v.source_mapping['start']) + int(v.source_mapping['length']) + old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + if(name[0] == '_'): + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', + r'\1'+name[0]+name[1].upper()+name[2:] + + r'\2', old_str_of_interest.decode('utf-8'), + 1) + else: + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+'_' + + name[0].upper()+name[1:]+r'\2', + old_str_of_interest.decode('utf-8'), 1) + if num_repl != 0: + patch = { + "file" : in_file, + "detector" : "naming-convention (parameter uses)", + "start" : modify_loc_start, + "end" : modify_loc_end, + "old_string" : old_str_of_interest.decode('utf-8'), + "new_string" : new_str_of_interest + } + if not patch in patches[in_file_relative]: + patches[in_file_relative].append(patch) + else: + raise SlitherException("Could not find parameter use?!") + + # Process function parameters passed to modifiers + for modifier in function._expression_modifiers: + for arg in modifier.arguments: + if str(arg) == name: + old_str_of_interest = in_file_str[modifier.source_mapping['start']: + modifier.source_mapping['start'] + + modifier.source_mapping['length']] + old_str_of_interest_beyond_modifier_name = old_str_of_interest.decode('utf-8')\ + .split('(')[1] + if(name[0] == '_'): + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+name[0]+ + name[1].upper()+name[2:]+r'\2', + old_str_of_interest_beyond_modifier_name, 1) + else: + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+'_'+ + name[0].upper()+name[1:]+r'\2', + old_str_of_interest_beyond_modifier_name, 1) + if num_repl != 0: + patch = { + "file" : in_file, + "detector" : "naming-convention (parameter uses)", + "start" : modifier.source_mapping['start'] + + len(old_str_of_interest.decode('utf-8').split('(')[0]) + 1, + "end" : modifier.source_mapping['start'] + modifier.source_mapping['length'], + "old_string" : old_str_of_interest_beyond_modifier_name, + "new_string" : new_str_of_interest + } + if not patch in patches[in_file_relative]: + patches[in_file_relative].append(patch) + else: + raise SlitherException("Could not find parameter use in modifier?!") def _create_patch_state_variable_declaration(format_info): @@ -535,28 +542,33 @@ def _create_patch_state_variable_declaration(format_info): modify_loc_start, modify_loc_end = format_info.loc_start, format_info.loc_end _target = format_info.target - for contract in slither.contracts: - if (contract.name == contract_name): - for var in contract.state_variables: - if (var.name == name): - in_file_str = slither.source_code[in_file].encode('utf-8') - old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - m = re.search(name, old_str_of_interest.decode('utf-8')) - if (_target == "variable_constant"): - new_string = old_str_of_interest.decode('utf-8')[m.span()[0]:m.span()[1]].upper() - else: - new_string = old_str_of_interest.decode('utf-8')[m.span()[0]:m.span()[1]] - new_string = new_string[0].lower()+new_string[1:] - patch = { - "file" : in_file, - "detector" : "naming-convention (state variable declaration)", - "start" : modify_loc_start+m.span()[0], - "end" : modify_loc_start+m.span()[1], - "old_string" : old_str_of_interest.decode('utf-8')[m.span()[0]:m.span()[1]], - "new_string" : new_string - } - if not patch in patches[in_file_relative]: - patches[in_file_relative].append(patch) + target_contract = slither.get_contract_from_name(contract_name) + if not target_contract: + raise SlitherException(f"Contract not found {contract_name}") + target_var = target_contract.get_state_variable_from_name(name) + if not target_var: + raise SlitherException(f"Contract not found {name}") + + # TODO (JF) target_var is not used, the above checks could be removed? + + in_file_str = slither.source_code[in_file].encode('utf-8') + old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + m = re.search(name, old_str_of_interest.decode('utf-8')) + if (_target == "variable_constant"): + new_string = old_str_of_interest.decode('utf-8')[m.span()[0]:m.span()[1]].upper() + else: + new_string = old_str_of_interest.decode('utf-8')[m.span()[0]:m.span()[1]] + new_string = new_string[0].lower()+new_string[1:] + patch = { + "file" : in_file, + "detector" : "naming-convention (state variable declaration)", + "start" : modify_loc_start+m.span()[0], + "end" : modify_loc_start+m.span()[1], + "old_string" : old_str_of_interest.decode('utf-8')[m.span()[0]:m.span()[1]], + "new_string" : new_string + } + if not patch in patches[in_file_relative]: + patches[in_file_relative].append(patch) def _create_patch_state_variable_uses(format_info): @@ -566,60 +578,32 @@ def _create_patch_state_variable_uses(format_info): _target = format_info.target # To-do: Check cross-contract state variable uses - for contract in slither.contracts: - if (contract.name == contract_name): - target_contract = contract - for contract in slither.contracts: - if (contract == target_contract or (contract in target_contract.derived_contracts)): - fms = contract.functions + contract.modifiers - for fm in fms: - for node in fm.nodes: - vars = node._expression_vars_written + node._expression_vars_read - for v in vars: - if isinstance(v, Identifier) and str(v) == name and [str(sv) for sv in - (node._state_vars_read + - node._state_vars_written) - if str(sv) == name]: - modify_loc_start = int(v.source_mapping['start']) - modify_loc_end = int(v.source_mapping['start']) + int(v.source_mapping['length']) - in_file_str = slither.source_code[in_file].encode('utf-8') - old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - if (_target == "variable_constant"): - new_str_of_interest = old_str_of_interest.decode('utf-8').upper() - else: - new_str_of_interest = old_str_of_interest.decode('utf-8') - new_str_of_interest = new_str_of_interest[0].lower()+new_str_of_interest[1:] - patch = { - "file" : in_file, - "detector" : "naming-convention (state variable uses)", - "start" : modify_loc_start, - "end" : modify_loc_end, - "old_string" : old_str_of_interest.decode('utf-8'), - "new_string" : new_str_of_interest - } - if not patch in patches[in_file_relative]: - patches[in_file_relative].append(patch) - - -def _create_patch_enum_definition(format_info): - slither, patches, name = format_info.slither, format_info.patches, format_info.name - in_file, in_file_relative = format_info.in_file, format_info.in_file_relative - contract_name = format_info.contract_name - modify_loc_start, modify_loc_end = format_info.loc_start, format_info.loc_end + target_contract = slither.get_contract_from_name(contract_name) + if not target_contract: + raise SlitherException(f"Contract not found {contract_name}") - for contract in slither.contracts: - if (contract.name == contract_name): - for enum in contract.enums: - if (enum.name == name): - in_file_str = slither.source_code[in_file].encode('utf-8') - old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"enum"+r'(.*)'+name, r'\1'+"enum"+r'\2'+ - name[0].capitalize()+name[1:], - old_str_of_interest.decode('utf-8'), 1) - if num_repl != 0: + for contract in [target_contract] + target_contract.derived_contracts: + fms = contract.functions + contract.modifiers + for fm in fms: + for node in fm.nodes: + vars = node._expression_vars_written + node._expression_vars_read + for v in vars: + if isinstance(v, Identifier) and str(v) == name and [str(sv) for sv in + (node._state_vars_read + + node._state_vars_written) + if str(sv) == name]: + modify_loc_start = int(v.source_mapping['start']) + modify_loc_end = int(v.source_mapping['start']) + int(v.source_mapping['length']) + in_file_str = slither.source_code[in_file].encode('utf-8') + old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + if (_target == "variable_constant"): + new_str_of_interest = old_str_of_interest.decode('utf-8').upper() + else: + new_str_of_interest = old_str_of_interest.decode('utf-8') + new_str_of_interest = new_str_of_interest[0].lower()+new_str_of_interest[1:] patch = { "file" : in_file, - "detector" : "naming-convention (enum definition)", + "detector" : "naming-convention (state variable uses)", "start" : modify_loc_start, "end" : modify_loc_end, "old_string" : old_str_of_interest.decode('utf-8'), @@ -627,8 +611,42 @@ def _create_patch_enum_definition(format_info): } if not patch in patches[in_file_relative]: patches[in_file_relative].append(patch) - else: - raise SlitherException("Could not find enum?!") + + +def _create_patch_enum_definition(format_info): + slither, patches, name = format_info.slither, format_info.patches, format_info.name + in_file, in_file_relative = format_info.in_file, format_info.in_file_relative + contract_name = format_info.contract_name + modify_loc_start, modify_loc_end = format_info.loc_start, format_info.loc_end + + target_contract = slither.get_contract_from_name(contract_name) + if not target_contract: + raise SlitherException(f"Contract not found {contract_name}") + + target_enum = slither.get_enum_from_name(name) + if not target_enum: + raise SlitherException(f"Enum not found {name}") + + # TODO (JF) target_enum is not used, the above checks could be removed? + + in_file_str = slither.source_code[in_file].encode('utf-8') + old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"enum"+r'(.*)'+name, r'\1'+"enum"+r'\2'+ + name[0].capitalize()+name[1:], + old_str_of_interest.decode('utf-8'), 1) + if num_repl != 0: + patch = { + "file" : in_file, + "detector" : "naming-convention (enum definition)", + "start" : modify_loc_start, + "end" : modify_loc_end, + "old_string" : old_str_of_interest.decode('utf-8'), + "new_string" : new_str_of_interest + } + if not patch in patches[in_file_relative]: + patches[in_file_relative].append(patch) + else: + raise SlitherException("Could not find enum?!") def _create_patch_enum_uses(format_info): @@ -636,87 +654,87 @@ def _create_patch_enum_uses(format_info): in_file, in_file_relative = format_info.in_file, format_info.in_file_relative contract_name = format_info.contract_name - for contract in slither.contracts: - if (contract.name == contract_name): - target_contract = contract - for contract in slither.contracts: - if (contract == target_contract or (contract in target_contract.derived_contracts)): - in_file_str = slither.source_code[in_file].encode('utf-8') - # Check state variable declarations of enum type - # To-do: Deep-check aggregate types (struct and mapping) - svs = contract.variables - for sv in svs: - if (str(sv.type) == contract_name + "." + name): - old_str_of_interest = in_file_str[sv.source_mapping['start']:(sv.source_mapping['start']+ - sv.source_mapping['length'])] + target_contract = slither.get_contract_from_name(contract_name) + if not target_contract: + raise SlitherException(f"Contract not found {contract_name}") + + for contract in [target_contract] + target_contract.derived_contracts: + in_file_str = slither.source_code[in_file].encode('utf-8') + # Check state variable declarations of enum type + # To-do: Deep-check aggregate types (struct and mapping) + svs = contract.variables + for sv in svs: + if (str(sv.type) == contract_name + "." + name): + old_str_of_interest = in_file_str[sv.source_mapping['start']:(sv.source_mapping['start']+ + sv.source_mapping['length'])] + (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(), + old_str_of_interest.decode('utf-8'), 1) + patch = { + "file" : in_file, + "detector" : "naming-convention (enum use)", + "start" : sv.source_mapping['start'], + "end" : sv.source_mapping['start'] + sv.source_mapping['length'], + "old_string" : old_str_of_interest.decode('utf-8'), + "new_string" : new_str_of_interest + } + if not patch in patches[in_file_relative]: + patches[in_file_relative].append(patch) + # Check function+modifier locals+parameters+returns + # To-do: Deep-check aggregate types (struct and mapping) + fms = contract.functions + contract.modifiers + for fm in fms: + # Enum declarations + for v in fm.variables: + if (str(v.type) == contract_name + "." + name): + old_str_of_interest = in_file_str[v.source_mapping['start']:(v.source_mapping['start']+ + v.source_mapping['length'])] (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(), old_str_of_interest.decode('utf-8'), 1) patch = { "file" : in_file, "detector" : "naming-convention (enum use)", - "start" : sv.source_mapping['start'], - "end" : sv.source_mapping['start'] + sv.source_mapping['length'], + "start" : v.source_mapping['start'], + "end" : v.source_mapping['start'] + v.source_mapping['length'], "old_string" : old_str_of_interest.decode('utf-8'), "new_string" : new_str_of_interest } - if not patch in patches[in_file_relative]: + if not patch in patches[in_file_relative]: patches[in_file_relative].append(patch) - # Check function+modifier locals+parameters+returns - # To-do: Deep-check aggregate types (struct and mapping) - fms = contract.functions + contract.modifiers - for fm in fms: - # Enum declarations - for v in fm.variables: - if (str(v.type) == contract_name + "." + name): - old_str_of_interest = in_file_str[v.source_mapping['start']:(v.source_mapping['start']+ - v.source_mapping['length'])] - (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(), - old_str_of_interest.decode('utf-8'), 1) - patch = { - "file" : in_file, - "detector" : "naming-convention (enum use)", - "start" : v.source_mapping['start'], - "end" : v.source_mapping['start'] + v.source_mapping['length'], - "old_string" : old_str_of_interest.decode('utf-8'), - "new_string" : new_str_of_interest - } - if not patch in patches[in_file_relative]: - patches[in_file_relative].append(patch) - # Capture enum uses such as "num = numbers.ONE;" - for function in contract.functions: - for node in function.nodes: - for ir in node.irs: - if isinstance(ir, Member): - if str(ir.variable_left) == name: - old_str_of_interest = in_file_str[node.source_mapping['start']: - (node.source_mapping['start']+ - node.source_mapping['length'])].decode('utf-8')\ - .split('=')[1] - m = re.search(r'(.*)'+name, old_str_of_interest) - old_str_of_interest = old_str_of_interest[m.span()[0]:] - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name, r'\1'+name[0].upper()+name[1:], - old_str_of_interest, 1) - if num_repl != 0: - patch = { - "file" : in_file, - "detector" : "naming-convention (enum use)", - "start" : node.source_mapping['start'] + - len(in_file_str[node.source_mapping['start']: - (node.source_mapping['start']+ - node.source_mapping['length'])].decode('utf-8').split('=')[0]) + - 1 + m.span()[0], - "end" : node.source_mapping['start'] + - len(in_file_str[node.source_mapping['start']:(node.source_mapping['start']+ - node.source_mapping['length'])].\ - decode('utf-8').split('=')[0]) + 1 + m.span()[0] + len(old_str_of_interest), - "old_string" : old_str_of_interest, - "new_string" : new_str_of_interest - } - if not patch in patches[in_file_relative]: - patches[in_file_relative].append(patch) - else: - raise SlitherException("Could not find new object?!") - # To-do: Check any other place/way where enum type is used + # Capture enum uses such as "num = numbers.ONE;" + for function in contract.functions: + for node in function.nodes: + for ir in node.irs: + if isinstance(ir, Member): + if str(ir.variable_left) == name: + old_str_of_interest = in_file_str[node.source_mapping['start']: + (node.source_mapping['start']+ + node.source_mapping['length'])].decode('utf-8')\ + .split('=')[1] + m = re.search(r'(.*)'+name, old_str_of_interest) + old_str_of_interest = old_str_of_interest[m.span()[0]:] + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name, r'\1'+name[0].upper()+name[1:], + old_str_of_interest, 1) + if num_repl != 0: + patch = { + "file" : in_file, + "detector" : "naming-convention (enum use)", + "start" : node.source_mapping['start'] + + len(in_file_str[node.source_mapping['start']: + (node.source_mapping['start']+ + node.source_mapping['length'])].decode('utf-8').split('=')[0]) + + 1 + m.span()[0], + "end" : node.source_mapping['start'] + + len(in_file_str[node.source_mapping['start']:(node.source_mapping['start']+ + node.source_mapping['length'])].\ + decode('utf-8').split('=')[0]) + 1 + m.span()[0] + len(old_str_of_interest), + "old_string" : old_str_of_interest, + "new_string" : new_str_of_interest + } + if not patch in patches[in_file_relative]: + patches[in_file_relative].append(patch) + else: + raise SlitherException("Could not find new object?!") + # To-do: Check any other place/way where enum type is used def _create_patch_struct_definition(format_info): @@ -725,28 +743,34 @@ def _create_patch_struct_definition(format_info): contract_name = format_info.contract_name modify_loc_start, modify_loc_end = format_info.loc_start, format_info.loc_end - for contract in slither.contracts: - if (contract.name == contract_name): - for struct in contract.structures: - if (struct.name == name): - in_file_str = slither.source_code[in_file].encode('utf-8') - old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"struct"+r'(.*)'+name, r'\1'+"struct"+r'\2'+ - name[0].capitalize()+name[1:], - old_str_of_interest.decode('utf-8'), 1) - if num_repl != 0: - patch = { - "file" : in_file, - "detector" : "naming-convention (struct definition)", - "start" : modify_loc_start, - "end" : modify_loc_end, - "old_string" : old_str_of_interest.decode('utf-8'), - "new_string" : new_str_of_interest - } - if not patch in patches[in_file_relative]: - patches[in_file_relative].append(patch) - else: - raise SlitherException("Could not find struct?!") + target_contract = slither.get_contract_from_name(contract_name) + if not target_contract: + raise SlitherException(f"Contract not found {contract_name}") + + target_structure = slither.get_structure_from_name(name) + if not target_structure: + raise SlitherException(f"Structure not found {name}") + + # TODO (JF) target_structure is not used, the above checks could be removed? + + in_file_str = slither.source_code[in_file].encode('utf-8') + old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"struct"+r'(.*)'+name, r'\1'+"struct"+r'\2'+ + name[0].capitalize()+name[1:], + old_str_of_interest.decode('utf-8'), 1) + if num_repl != 0: + patch = { + "file" : in_file, + "detector" : "naming-convention (struct definition)", + "start" : modify_loc_start, + "end" : modify_loc_end, + "old_string" : old_str_of_interest.decode('utf-8'), + "new_string" : new_str_of_interest + } + if not patch in patches[in_file_relative]: + patches[in_file_relative].append(patch) + else: + raise SlitherException("Could not find struct?!") def _create_patch_struct_uses(format_info): @@ -754,49 +778,49 @@ def _create_patch_struct_uses(format_info): in_file, in_file_relative = format_info.in_file, format_info.in_file_relative contract_name = format_info.contract_name - for contract in slither.contracts: - if (contract.name == contract_name): - target_contract = contract - for contract in slither.contracts: - if (contract == target_contract or (contract in target_contract.derived_contracts)): - in_file_str = slither.source_code[in_file].encode('utf-8') - # Check state variables of struct type - # To-do: Deep-check aggregate types (struct and mapping) - svs = contract.variables - for sv in svs: - if (str(sv.type) == contract_name + "." + name): - old_str_of_interest = in_file_str[sv.source_mapping['start']:(sv.source_mapping['start']+ - sv.source_mapping['length'])] + target_contract = slither.get_contract_from_name(contract_name) + if not target_contract: + raise SlitherException(f"Contract not found {contract_name}") + + for contract in [target_contract] + target_contract.derived_contracts: + in_file_str = slither.source_code[in_file].encode('utf-8') + # Check state variables of struct type + # To-do: Deep-check aggregate types (struct and mapping) + svs = contract.variables + for sv in svs: + if (str(sv.type) == contract_name + "." + name): + old_str_of_interest = in_file_str[sv.source_mapping['start']:(sv.source_mapping['start']+ + sv.source_mapping['length'])] + (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(), + old_str_of_interest.decode('utf-8'), 1) + patch = { + "file" : in_file, + "detector" : "naming-convention (struct use)", + "start" : sv.source_mapping['start'], + "end" : sv.source_mapping['start'] + sv.source_mapping['length'], + "old_string" : old_str_of_interest.decode('utf-8'), + "new_string" : new_str_of_interest + } + if not patch in patches[in_file_relative]: + patches[in_file_relative].append(patch) + # Check function+modifier locals+parameters+returns + # To-do: Deep-check aggregate types (struct and mapping) + fms = contract.functions + contract.modifiers + for fm in fms: + for v in fm.variables: + if (str(v.type) == contract_name + "." + name): + old_str_of_interest = in_file_str[v.source_mapping['start']:(v.source_mapping['start']+ + v.source_mapping['length'])] (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(), old_str_of_interest.decode('utf-8'), 1) patch = { "file" : in_file, "detector" : "naming-convention (struct use)", - "start" : sv.source_mapping['start'], - "end" : sv.source_mapping['start'] + sv.source_mapping['length'], + "start" : v.source_mapping['start'], + "end" : v.source_mapping['start'] + v.source_mapping['length'], "old_string" : old_str_of_interest.decode('utf-8'), "new_string" : new_str_of_interest } if not patch in patches[in_file_relative]: patches[in_file_relative].append(patch) - # Check function+modifier locals+parameters+returns - # To-do: Deep-check aggregate types (struct and mapping) - fms = contract.functions + contract.modifiers - for fm in fms: - for v in fm.variables: - if (str(v.type) == contract_name + "." + name): - old_str_of_interest = in_file_str[v.source_mapping['start']:(v.source_mapping['start']+ - v.source_mapping['length'])] - (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(), - old_str_of_interest.decode('utf-8'), 1) - patch = { - "file" : in_file, - "detector" : "naming-convention (struct use)", - "start" : v.source_mapping['start'], - "end" : v.source_mapping['start'] + v.source_mapping['length'], - "old_string" : old_str_of_interest.decode('utf-8'), - "new_string" : new_str_of_interest - } - if not patch in patches[in_file_relative]: - patches[in_file_relative].append(patch) - # To-do: Check any other place/way where struct type is used (e.g. typecast) + # To-do: Check any other place/way where struct type is used (e.g. typecast) From 0dacdddaa436055027bea0ec609f743bcbb4c9f5 Mon Sep 17 00:00:00 2001 From: Josselin Date: Tue, 25 Jun 2019 10:52:36 +0200 Subject: [PATCH 063/223] slither-format : use utils.patches.create_patch in naming convention --- .../formatters/naming_convention.py | 456 +++++++++--------- utils/slither_format/utils/patches.py | 8 +- 2 files changed, 223 insertions(+), 241 deletions(-) diff --git a/utils/slither_format/formatters/naming_convention.py b/utils/slither_format/formatters/naming_convention.py index 6580e03b6..9ee121ccf 100644 --- a/utils/slither_format/formatters/naming_convention.py +++ b/utils/slither_format/formatters/naming_convention.py @@ -4,6 +4,7 @@ from slither.exceptions import SlitherException from slither.core.expressions.identifier import Identifier from slither.slithir.operations import NewContract from slither.slithir.operations import Member +from ..utils.patches import create_patch # The Namedtuple will be used to give all the parameters from _patch to the _create_X functions # Its used to improve code readability and avoid incorrect parameters order @@ -122,16 +123,14 @@ def _create_patch_contract_definition(format_info): r'\1'+"contract"+r'\2'+format_info.name.capitalize(), old_str_of_interest.decode('utf-8'), 1) if num_repl != 0: - patch = { - "file" : format_info.in_file, - "detector" : "naming-convention (contract definition)", - "start": format_info.loc_start, - "end": format_info.loc_start+m.span()[1], - "old_string":old_str_of_interest.decode('utf-8'), - "new_string":new_str_of_interest - } - if not patch in format_info.patches[format_info.in_file_relative]: - format_info.patches[format_info.in_file_relative].append(patch) + create_patch(format_info.patches, + "naming-convention (contract definition)", + format_info.in_file_relative, + format_info.in_file, + format_info.loc_start, + format_info.loc_start + m.span()[1], + old_str_of_interest.decode('utf-8'), + new_str_of_interest) else: raise SlitherException("Could not find contract?!") @@ -153,16 +152,14 @@ def _create_patch_contract_uses(format_info): sv.source_mapping['length'])] (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(), old_str_of_interest.decode('utf-8'), 1) - patch = { - "file" : in_file, - "detector" : "naming-convention (contract state variable)", - "start" : sv.source_mapping['start'], - "end" : sv.source_mapping['start'] + sv.source_mapping['length'], - "old_string" : old_str_of_interest.decode('utf-8'), - "new_string" : new_str_of_interest - } - if not patch in patches[in_file_relative]: - patches[in_file_relative].append(patch) + create_patch(patches, + "naming-convention (contract state variable)", + in_file_relative, + in_file, + sv.source_mapping['start'], + sv.source_mapping['start'] + sv.source_mapping['length'], + old_str_of_interest.decode('utf-8'), + new_str_of_interest) # Check function+modifier locals+parameters+returns # To-do: Deep-check aggregate types (struct and mapping) fms = contract.functions + contract.modifiers @@ -173,16 +170,16 @@ def _create_patch_contract_uses(format_info): v.source_mapping['length'])] old_str_of_interest = old_str_of_interest.decode('utf-8').split('=')[0] (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(),old_str_of_interest, 1) - patch = { - "file" : in_file, - "detector" : "naming-convention (contract function variable)", - "start" : v.source_mapping['start'], - "end" : v.source_mapping['start'] + len(old_str_of_interest), - "old_string" : old_str_of_interest, - "new_string" : new_str_of_interest - } - if not patch in patches[in_file_relative]: - patches[in_file_relative].append(patch) + + create_patch(patches, + "naming-convention (contract function variable)", + in_file_relative, + in_file, + v.source_mapping['start'], + v.source_mapping['start'] + len(old_str_of_interest), + old_str_of_interest, + new_str_of_interest) + # Check "new" expressions for creation of contract objects for function in contract.functions: for node in function.nodes: @@ -195,16 +192,14 @@ def _create_patch_contract_uses(format_info): (new_str_of_interest, num_repl) = re.subn("new"+r'(.*)'+name, "new"+r'\1'+name[0].upper() + name[1:], old_str_of_interest, 1) if num_repl != 0: - patch = { - "file" : in_file, - "detector" : "naming-convention (contract new object)", - "start" : node.source_mapping['start'] + m.span()[0], - "end" : node.source_mapping['start'] + m.span()[1], - "old_string" : old_str_of_interest, - "new_string" : new_str_of_interest - } - if not patch in patches[in_file_relative]: - patches[in_file_relative].append(patch) + create_patch(patches, + "naming-convention (contract new object)", + in_file_relative, + in_file, + node.source_mapping['start'] + m.span()[0], + node.source_mapping['start'] + m.span()[1], + old_str_of_interest, + new_str_of_interest) else: raise SlitherException("Could not find new object?!") @@ -227,16 +222,14 @@ def _create_patch_modifier_definition(format_info): (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"modifier"+r'(.*)'+name, r'\1'+"modifier"+r'\2' + name[0].lower()+name[1:], old_str_of_interest.decode('utf-8'), 1) if num_repl != 0: - patch = { - "file" : in_file, - "detector" : "naming-convention (modifier definition)", - "start" : modify_loc_start, - "end" : modify_loc_start+m.span()[1], - "old_string" : old_str_of_interest.decode('utf-8'), - "new_string" : new_str_of_interest - } - if not patch in patches[in_file_relative]: - patches[in_file_relative].append(patch) + create_patch(patches, + "naming-convention (modifier definition)", + in_file_relative, + in_file, + modify_loc_start, + modify_loc_start + m.span()[1], + old_str_of_interest.decode('utf-8'), + new_str_of_interest) else: raise SlitherException("Could not find modifier?!") @@ -259,16 +252,14 @@ def _create_patch_modifier_uses(format_info): (new_str_of_interest, num_repl) = re.subn(name, name[0].lower()+name[1:], old_str_of_interest.decode('utf-8'),1) if num_repl != 0: - patch = { - "file" : in_file, - "detector" : "naming-convention (modifier uses)", - "start" : int(function.parameters_src.source_mapping['start']), - "end" : int(function.returns_src.source_mapping['start']), - "old_string" : old_str_of_interest.decode('utf-8'), - "new_string" : new_str_of_interest - } - if not patch in patches[in_file_relative]: - patches[in_file_relative].append(patch) + create_patch(patches, + "naming-convention (modifier uses)", + in_file_relative, + in_file, + int(function.parameters_src.source_mapping['start']), + int(function.returns_src.source_mapping['start']), + old_str_of_interest.decode('utf-8'), + new_str_of_interest) else: raise SlitherException("Could not find modifier name?!") @@ -291,16 +282,15 @@ def _create_patch_function_definition(format_info): (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"function"+r'(.*)'+name, r'\1'+"function"+r'\2'+ name[0].lower()+name[1:], old_str_of_interest.decode('utf-8'), 1) if num_repl != 0: - patch = { - "file" : in_file, - "detector" : "naming-convention (function definition)", - "start" : modify_loc_start, - "end" : modify_loc_start+m.span()[1], - "old_string" : old_str_of_interest.decode('utf-8'), - "new_string" : new_str_of_interest - } - if not patch in patches[in_file_relative]: - patches[in_file_relative].append(patch) + create_patch(patches, + "naming-convention (function definition)", + in_file_relative, + in_file, + modify_loc_start, + modify_loc_start+m.span()[1], + old_str_of_interest.decode('utf-8'), + new_str_of_interest) + else: raise SlitherException("Could not find function?!") @@ -325,18 +315,16 @@ def _create_patch_function_calls(format_info): called_function_name = old_str_of_interest.decode('utf-8').split('.')[-1] fixed_function_name = called_function_name[0].lower() + called_function_name[1:] new_string = '.'.join(old_str_of_interest.decode('utf-8').split('.')[:-1]) + '.' + \ - fixed_function_name - patch = { - "file" : in_file, - "detector" : "naming-convention (function calls)", - "start" : external_call.source_mapping['start'], - "end" : int(external_call.source_mapping['start']) + - int(external_call.source_mapping['length']), - "old_string" : old_str_of_interest.decode('utf-8'), - "new_string" : new_string - } - if not patch in patches[in_file_relative]: - patches[in_file_relative].append(patch) + fixed_function_name + create_patch(patches, + "naming-convention (function calls)", + in_file_relative, + in_file, + external_call.source_mapping['start'], + int(external_call.source_mapping['start']) + + int(external_call.source_mapping['length']), + old_str_of_interest.decode('utf-8'), + new_string) for internal_call in node.internal_calls_as_expressions: if (str(internal_call.called) == name): in_file_str = slither.source_code[in_file].encode('utf-8') @@ -344,21 +332,22 @@ def _create_patch_function_calls(format_info): int(internal_call.source_mapping['start']) + int(internal_call.source_mapping['length'])] old_str_of_interest = old_str_of_interest.decode('utf-8').split('(')[0] - patch = { - "file" : in_file, - "detector" : "naming-convention (function calls)", - "start" : internal_call.source_mapping['start'], - "end" : int(internal_call.source_mapping['start']) + - int(internal_call.source_mapping['length']) - + # Avoid parameters + # TODO: (JF) review me + end_loc = int(internal_call.source_mapping['start']) + \ + int(internal_call.source_mapping['length']) - \ len('('.join(in_file_str[int(internal_call.source_mapping['start']): int(internal_call.source_mapping['start']) + int(internal_call.source_mapping['length'])] \ - .decode('utf-8').split('(')[1:])) - 1, - "old_string" : old_str_of_interest, - "new_string" : old_str_of_interest[0].lower()+old_str_of_interest[1:] - } - if not patch in patches[in_file_relative]: - patches[in_file_relative].append(patch) + .decode('utf-8').split('(')[1:])) - 1 + create_patch(patches, + "naming-convention (function calls)", + in_file_relative, + in_file, + internal_call.source_mapping['start'], + end_loc, + old_str_of_interest, + old_str_of_interest[0].lower()+old_str_of_interest[1:]) def _create_patch_event_definition(format_info): @@ -379,16 +368,14 @@ def _create_patch_event_definition(format_info): event_name[0].capitalize()+event_name[1:], old_str_of_interest.decode('utf-8'), 1) if num_repl != 0: - patch = { - "file" : in_file, - "detector" : "naming-convention (event definition)", - "start" : modify_loc_start, - "end" : modify_loc_end, - "old_string" : old_str_of_interest.decode('utf-8'), - "new_string" : new_str_of_interest - } - if not patch in patches[in_file_relative]: - patches[in_file_relative].append(patch) + create_patch(patches, + "naming-convention (event definition)", + in_file_relative, + in_file, + modify_loc_start, + modify_loc_end, + old_str_of_interest.decode('utf-8'), + new_str_of_interest) else: raise SlitherException("Could not find event?!") @@ -411,17 +398,16 @@ def _create_patch_event_calls(format_info): old_str_of_interest = in_file_str[int(call.source_mapping['start']): int(call.source_mapping['start']) + int(call.source_mapping['length'])] - patch = { - "file" : in_file, - "detector" : "naming-convention (event calls)", - "start" : call.source_mapping['start'], - "end" : int(call.source_mapping['start']) + int(call.source_mapping['length']), - "old_string" : old_str_of_interest.decode('utf-8'), - "new_string" : old_str_of_interest.decode('utf-8')[0].capitalize() + - old_str_of_interest.decode('utf-8')[1:] - } - if not patch in patches[in_file_relative]: - patches[in_file_relative].append(patch) + + create_patch(patches, + "naming-convention (event calls)", + in_file_relative, + in_file, + call.source_mapping['start'], + int(call.source_mapping['start']) + int(call.source_mapping['length']), + old_str_of_interest.decode('utf-8'), + old_str_of_interest.decode('utf-8')[0].capitalize() + + old_str_of_interest.decode('utf-8')[1:]) def _create_patch_parameter_declaration(format_info): @@ -445,16 +431,14 @@ def _create_patch_parameter_declaration(format_info): (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+'_'+name[0].upper() + name[1:]+r'\2', old_str_of_interest.decode('utf-8'), 1) if num_repl != 0: - patch = { - "file" : in_file, - "detector" : "naming-convention (parameter declaration)", - "start" : modify_loc_start, - "end" : modify_loc_end, - "old_string" : old_str_of_interest.decode('utf-8'), - "new_string" : new_str_of_interest - } - if not patch in patches[in_file_relative]: - patches[in_file_relative].append(patch) + create_patch(patches, + "naming-convention (parameter declaration)", + in_file_relative, + in_file, + modify_loc_start, + modify_loc_end, + old_str_of_interest.decode('utf-8'), + new_str_of_interest) else: raise SlitherException("Could not find parameter declaration?!") @@ -489,16 +473,14 @@ def _create_patch_parameter_uses(format_info): name[0].upper()+name[1:]+r'\2', old_str_of_interest.decode('utf-8'), 1) if num_repl != 0: - patch = { - "file" : in_file, - "detector" : "naming-convention (parameter uses)", - "start" : modify_loc_start, - "end" : modify_loc_end, - "old_string" : old_str_of_interest.decode('utf-8'), - "new_string" : new_str_of_interest - } - if not patch in patches[in_file_relative]: - patches[in_file_relative].append(patch) + create_patch(patches, + "naming-convention (parameter uses)", + in_file_relative, + in_file, + modify_loc_start, + modify_loc_end, + old_str_of_interest.decode('utf-8'), + new_str_of_interest) else: raise SlitherException("Could not find parameter use?!") @@ -520,17 +502,15 @@ def _create_patch_parameter_uses(format_info): name[0].upper()+name[1:]+r'\2', old_str_of_interest_beyond_modifier_name, 1) if num_repl != 0: - patch = { - "file" : in_file, - "detector" : "naming-convention (parameter uses)", - "start" : modifier.source_mapping['start'] + - len(old_str_of_interest.decode('utf-8').split('(')[0]) + 1, - "end" : modifier.source_mapping['start'] + modifier.source_mapping['length'], - "old_string" : old_str_of_interest_beyond_modifier_name, - "new_string" : new_str_of_interest - } - if not patch in patches[in_file_relative]: - patches[in_file_relative].append(patch) + create_patch(patches, + "naming-convention (parameter uses)", + in_file_relative, + in_file, + modifier.source_mapping['start'] + + len(old_str_of_interest.decode('utf-8').split('(')[0]) + 1, + modifier.source_mapping['start'] + modifier.source_mapping['length'], + old_str_of_interest_beyond_modifier_name, + new_str_of_interest) else: raise SlitherException("Could not find parameter use in modifier?!") @@ -559,16 +539,15 @@ def _create_patch_state_variable_declaration(format_info): else: new_string = old_str_of_interest.decode('utf-8')[m.span()[0]:m.span()[1]] new_string = new_string[0].lower()+new_string[1:] - patch = { - "file" : in_file, - "detector" : "naming-convention (state variable declaration)", - "start" : modify_loc_start+m.span()[0], - "end" : modify_loc_start+m.span()[1], - "old_string" : old_str_of_interest.decode('utf-8')[m.span()[0]:m.span()[1]], - "new_string" : new_string - } - if not patch in patches[in_file_relative]: - patches[in_file_relative].append(patch) + + create_patch(patches, + "naming-convention (state variable declaration)", + in_file_relative, + in_file, + modify_loc_start+m.span()[0], + modify_loc_start+m.span()[1], + old_str_of_interest.decode('utf-8')[m.span()[0]:m.span()[1]], + new_string) def _create_patch_state_variable_uses(format_info): @@ -601,16 +580,15 @@ def _create_patch_state_variable_uses(format_info): else: new_str_of_interest = old_str_of_interest.decode('utf-8') new_str_of_interest = new_str_of_interest[0].lower()+new_str_of_interest[1:] - patch = { - "file" : in_file, - "detector" : "naming-convention (state variable uses)", - "start" : modify_loc_start, - "end" : modify_loc_end, - "old_string" : old_str_of_interest.decode('utf-8'), - "new_string" : new_str_of_interest - } - if not patch in patches[in_file_relative]: - patches[in_file_relative].append(patch) + + create_patch(patches, + "naming-convention (state variable uses)", + in_file_relative, + in_file, + modify_loc_start, + modify_loc_end, + old_str_of_interest.decode('utf-8'), + new_str_of_interest) def _create_patch_enum_definition(format_info): @@ -635,16 +613,14 @@ def _create_patch_enum_definition(format_info): name[0].capitalize()+name[1:], old_str_of_interest.decode('utf-8'), 1) if num_repl != 0: - patch = { - "file" : in_file, - "detector" : "naming-convention (enum definition)", - "start" : modify_loc_start, - "end" : modify_loc_end, - "old_string" : old_str_of_interest.decode('utf-8'), - "new_string" : new_str_of_interest - } - if not patch in patches[in_file_relative]: - patches[in_file_relative].append(patch) + create_patch(patches, + "naming-convention (enum definition)", + in_file_relative, + in_file, + modify_loc_start, + modify_loc_end, + old_str_of_interest.decode('utf-8'), + new_str_of_interest) else: raise SlitherException("Could not find enum?!") @@ -669,16 +645,16 @@ def _create_patch_enum_uses(format_info): sv.source_mapping['length'])] (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(), old_str_of_interest.decode('utf-8'), 1) - patch = { - "file" : in_file, - "detector" : "naming-convention (enum use)", - "start" : sv.source_mapping['start'], - "end" : sv.source_mapping['start'] + sv.source_mapping['length'], - "old_string" : old_str_of_interest.decode('utf-8'), - "new_string" : new_str_of_interest - } - if not patch in patches[in_file_relative]: - patches[in_file_relative].append(patch) + + create_patch(patches, + "naming-convention (enum use)", + in_file_relative, + in_file, + sv.source_mapping['start'], + sv.source_mapping['start'] + sv.source_mapping['length'], + old_str_of_interest.decode('utf-8'), + new_str_of_interest) + # Check function+modifier locals+parameters+returns # To-do: Deep-check aggregate types (struct and mapping) fms = contract.functions + contract.modifiers @@ -690,16 +666,16 @@ def _create_patch_enum_uses(format_info): v.source_mapping['length'])] (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(), old_str_of_interest.decode('utf-8'), 1) - patch = { - "file" : in_file, - "detector" : "naming-convention (enum use)", - "start" : v.source_mapping['start'], - "end" : v.source_mapping['start'] + v.source_mapping['length'], - "old_string" : old_str_of_interest.decode('utf-8'), - "new_string" : new_str_of_interest - } - if not patch in patches[in_file_relative]: - patches[in_file_relative].append(patch) + + create_patch(patches, + "naming-convention (enum use)", + in_file_relative, + in_file, + v.source_mapping['start'], + v.source_mapping['start'] + v.source_mapping['length'], + old_str_of_interest.decode('utf-8'), + new_str_of_interest) + # Capture enum uses such as "num = numbers.ONE;" for function in contract.functions: for node in function.nodes: @@ -715,23 +691,28 @@ def _create_patch_enum_uses(format_info): (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name, r'\1'+name[0].upper()+name[1:], old_str_of_interest, 1) if num_repl != 0: - patch = { - "file" : in_file, - "detector" : "naming-convention (enum use)", - "start" : node.source_mapping['start'] + + + # TODO (JF): review me + loc_start = node.source_mapping['start'] + \ len(in_file_str[node.source_mapping['start']: (node.source_mapping['start']+ - node.source_mapping['length'])].decode('utf-8').split('=')[0]) + - 1 + m.span()[0], - "end" : node.source_mapping['start'] + + node.source_mapping['length'])].decode('utf-8').split('=')[0]) + \ + 1 + m.span()[0] + + loc_end = node.source_mapping['start'] +\ len(in_file_str[node.source_mapping['start']:(node.source_mapping['start']+ node.source_mapping['length'])].\ - decode('utf-8').split('=')[0]) + 1 + m.span()[0] + len(old_str_of_interest), - "old_string" : old_str_of_interest, - "new_string" : new_str_of_interest - } - if not patch in patches[in_file_relative]: - patches[in_file_relative].append(patch) + decode('utf-8').split('=')[0]) + 1 + m.span()[0] + len(old_str_of_interest) + + create_patch(patches, + "naming-convention (enum use)", + in_file_relative, + in_file, + loc_start, + loc_end, + old_str_of_interest, + new_str_of_interest) + else: raise SlitherException("Could not find new object?!") # To-do: Check any other place/way where enum type is used @@ -759,16 +740,15 @@ def _create_patch_struct_definition(format_info): name[0].capitalize()+name[1:], old_str_of_interest.decode('utf-8'), 1) if num_repl != 0: - patch = { - "file" : in_file, - "detector" : "naming-convention (struct definition)", - "start" : modify_loc_start, - "end" : modify_loc_end, - "old_string" : old_str_of_interest.decode('utf-8'), - "new_string" : new_str_of_interest - } - if not patch in patches[in_file_relative]: - patches[in_file_relative].append(patch) + create_patch(patches, + "naming-convention (struct definition)", + in_file_relative, + in_file, + modify_loc_start, + modify_loc_end, + old_str_of_interest.decode('utf-8'), + new_str_of_interest) + else: raise SlitherException("Could not find struct?!") @@ -793,16 +773,15 @@ def _create_patch_struct_uses(format_info): sv.source_mapping['length'])] (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(), old_str_of_interest.decode('utf-8'), 1) - patch = { - "file" : in_file, - "detector" : "naming-convention (struct use)", - "start" : sv.source_mapping['start'], - "end" : sv.source_mapping['start'] + sv.source_mapping['length'], - "old_string" : old_str_of_interest.decode('utf-8'), - "new_string" : new_str_of_interest - } - if not patch in patches[in_file_relative]: - patches[in_file_relative].append(patch) + + create_patch(patches, + "naming-convention (struct use)", + in_file_relative, + in_file, + sv.source_mapping['start'], + sv.source_mapping['start'] + sv.source_mapping['length'], + old_str_of_interest.decode('utf-8'), + new_str_of_interest) # Check function+modifier locals+parameters+returns # To-do: Deep-check aggregate types (struct and mapping) fms = contract.functions + contract.modifiers @@ -813,14 +792,13 @@ def _create_patch_struct_uses(format_info): v.source_mapping['length'])] (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(), old_str_of_interest.decode('utf-8'), 1) - patch = { - "file" : in_file, - "detector" : "naming-convention (struct use)", - "start" : v.source_mapping['start'], - "end" : v.source_mapping['start'] + v.source_mapping['length'], - "old_string" : old_str_of_interest.decode('utf-8'), - "new_string" : new_str_of_interest - } - if not patch in patches[in_file_relative]: - patches[in_file_relative].append(patch) + + create_patch(patches, + "naming-convention (struct use)", + in_file_relative, + in_file, + v.source_mapping['start'], + v.source_mapping['start'] + v.source_mapping['length'], + old_str_of_interest.decode('utf-8'), + new_str_of_interest) # To-do: Check any other place/way where struct type is used (e.g. typecast) diff --git a/utils/slither_format/utils/patches.py b/utils/slither_format/utils/patches.py index 85ea85297..9c6803bf1 100644 --- a/utils/slither_format/utils/patches.py +++ b/utils/slither_format/utils/patches.py @@ -1,10 +1,14 @@ def create_patch(patches, detector, file_relative, file, start, end, old_str, new_str): - patches[file_relative].append({ + p = { "file": file, "detector": detector, "start": start, "end": end, "old_string": old_str, "new_string": new_str - }) \ No newline at end of file + } + if not file_relative in patches: + patches[file_relative] = [] + if p not in patches[file_relative]: + patches[file_relative].append(p) \ No newline at end of file From 52f09f95a3e547b54139e67cdd9a48c6427c831a Mon Sep 17 00:00:00 2001 From: Josselin Date: Tue, 25 Jun 2019 11:30:07 +0200 Subject: [PATCH 064/223] Update to origin/dev-slither-format-tool-only-new --- .../formatters/constable_states.py | 1 + .../formatters/constant_function.py | 3 +- .../formatters/external_function.py | 15 ++-- .../formatters/naming_convention.py | 86 ++++++++++++++++--- utils/slither_format/formatters/pragma.py | 2 + .../slither_format/formatters/solc_version.py | 4 + .../slither_format/formatters/unused_state.py | 1 + utils/slither_format/slither_format.py | 10 ++- 8 files changed, 101 insertions(+), 21 deletions(-) diff --git a/utils/slither_format/formatters/constable_states.py b/utils/slither_format/formatters/constable_states.py index 1d05432ad..a274633eb 100644 --- a/utils/slither_format/formatters/constable_states.py +++ b/utils/slither_format/formatters/constable_states.py @@ -15,6 +15,7 @@ def format(slither, patches, elements): def _patch(slither, patches, in_file, in_file_relative, match_text, replace_text, modify_loc_start, modify_loc_end): in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + # Add keyword `constant` before the variable name (new_str_of_interest, num_repl) = re.subn(match_text, replace_text, old_str_of_interest.decode('utf-8'), 1) if num_repl != 0: create_patch( diff --git a/utils/slither_format/formatters/constant_function.py b/utils/slither_format/formatters/constant_function.py index e6a6cec64..00cf42dcb 100644 --- a/utils/slither_format/formatters/constant_function.py +++ b/utils/slither_format/formatters/constant_function.py @@ -22,6 +22,7 @@ def format(slither, patches, elements): def _patch(slither, patches, in_file, in_file_relative, modify_loc_start, modify_loc_end): in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + # Find the keywords view|pure|constant and remove them m = re.search("(view|pure|constant)", old_str_of_interest.decode('utf-8')) if m: create_patch(patches, @@ -30,7 +31,7 @@ def _patch(slither, patches, in_file, in_file_relative, modify_loc_start, modify in_file, modify_loc_start + m.span()[0], modify_loc_start + m.span()[1], - m.groups(0)[0], + m.groups(0)[0], # this is view|pure|constant "") else: raise SlitherException("No view/pure/constant specifier exists. Regex failed to remove specifier!") diff --git a/utils/slither_format/formatters/external_function.py b/utils/slither_format/formatters/external_function.py index 5e3a5fa45..1da1d7ea7 100644 --- a/utils/slither_format/formatters/external_function.py +++ b/utils/slither_format/formatters/external_function.py @@ -10,15 +10,16 @@ def format(slither, patches, elements): _patch(slither, patches, element['source_mapping']['filename_absolute'], element['source_mapping']['filename_relative'], - "external", int(function.parameters_src.source_mapping['start']), int(function.returns_src.source_mapping['start'])) break -def _patch(slither, patches, in_file, in_file_relative, replace_text, modify_loc_start, modify_loc_end): +def _patch(slither, patches, in_file, in_file_relative, modify_loc_start, modify_loc_end): in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + # Search for 'public' keyword which is in-between the function name and modifier name (if present) + # regex: 'public' could have spaces around or be at the end of the line m = re.search(r'((\spublic)\s+)|(\spublic)$|(\)public)$', old_str_of_interest.decode('utf-8')) if m is None: # No visibility specifier exists; public by default. @@ -26,16 +27,20 @@ def _patch(slither, patches, in_file, in_file_relative, replace_text, modify_loc "external-function", in_file_relative, in_file, + # start after the function definition's closing paranthesis modify_loc_start + len(old_str_of_interest.decode('utf-8').split(')')[0]) + 1, + # end is same as start because we insert the keyword `external` at that location modify_loc_start + len(old_str_of_interest.decode('utf-8').split(')')[0]) + 1, "", - " "+ replace_text) + " external") # replace_text is `external` else: create_patch(patches, "external-function", in_file_relative, in_file, + # start at the keyword `public` modify_loc_start + m.span()[0] + 1, + # end after the keyword `public` = start + len('public'') modify_loc_start + m.span()[0] + 1 + 6, - "", - " " + replace_text) + " public", + " external") diff --git a/utils/slither_format/formatters/naming_convention.py b/utils/slither_format/formatters/naming_convention.py index 9ee121ccf..b7da90450 100644 --- a/utils/slither_format/formatters/naming_convention.py +++ b/utils/slither_format/formatters/naming_convention.py @@ -117,11 +117,14 @@ def _patch(slither, patches, _target, name, function_name, contract_name, in_fil def _create_patch_contract_definition(format_info): in_file_str = format_info.slither.source_code[format_info.in_file].encode('utf-8') old_str_of_interest = in_file_str[format_info.loc_start:format_info.loc_end] - m = re.match(r'(.*)'+"contract"+r'(.*)'+format_info.name, old_str_of_interest.decode('utf-8')) + # Locate the name following keywords `contract` | `interface` | `library` + m = re.match(r'(.*)' + "(contract|interface|library)" + r'(.*)' + format_info.name, old_str_of_interest.decode('utf-8')) old_str_of_interest = in_file_str[format_info.loc_start:format_info.loc_start+m.span()[1]] - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"contract"+r'(.*)'+format_info.name, - r'\1'+"contract"+r'\2'+format_info.name.capitalize(), + # Capitalize the name + (new_str_of_interest, num_repl) = re.subn(r'(.*)' + r'(contract|interface|library)' + r'(.*)' + format_info.name, + r'\1' + r'\2' + r'\3' + format_info.name.capitalize(), old_str_of_interest.decode('utf-8'), 1) + if num_repl != 0: create_patch(format_info.patches, "naming-convention (contract definition)", @@ -150,6 +153,7 @@ def _create_patch_contract_uses(format_info): if (str(sv.type) == name): old_str_of_interest = in_file_str[sv.source_mapping['start']:(sv.source_mapping['start'] + sv.source_mapping['length'])] + # Get only the contract variable name even if it is initialised (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(), old_str_of_interest.decode('utf-8'), 1) create_patch(patches, @@ -187,15 +191,21 @@ def _create_patch_contract_uses(format_info): if isinstance(ir, NewContract) and ir.contract_name == name: old_str_of_interest = in_file_str[node.source_mapping['start']:node.source_mapping['start'] + node.source_mapping['length']] + # Search for the name after the `new` keyword m = re.search("new"+r'(.*)'+name, old_str_of_interest.decode('utf-8')) + # Skip rare cases where re search fails. To-do: Investigate + if not m: + continue old_str_of_interest = old_str_of_interest.decode('utf-8')[m.span()[0]:] - (new_str_of_interest, num_repl) = re.subn("new"+r'(.*)'+name, "new"+r'\1'+name[0].upper() + - name[1:], old_str_of_interest, 1) + (new_str_of_interest, num_repl) = re.subn("new" + r'(.*)' + format_info.name, + "new" + r'\1' + format_info.name.capitalize(), + format_info.name[1:], old_str_of_interest, 1) if num_repl != 0: create_patch(patches, "naming-convention (contract new object)", in_file_relative, in_file, + # start after the `new` keyword where the name begins node.source_mapping['start'] + m.span()[0], node.source_mapping['start'] + m.span()[1], old_str_of_interest, @@ -217,8 +227,10 @@ def _create_patch_modifier_definition(format_info): if modifier.name == name: in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + # Search for the modifier name after the `modifier` keyword m = re.match(r'(.*)'+"modifier"+r'(.*)'+name, old_str_of_interest.decode('utf-8')) old_str_of_interest = in_file_str[modify_loc_start:modify_loc_start+m.span()[1]] + # Change the first letter of the modifier name to lowercase (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"modifier"+r'(.*)'+name, r'\1'+"modifier"+r'\2' + name[0].lower()+name[1:], old_str_of_interest.decode('utf-8'), 1) if num_repl != 0: @@ -247,8 +259,12 @@ def _create_patch_modifier_uses(format_info): for m in function.modifiers: if (m.name == name): in_file_str = slither.source_code[in_file].encode('utf-8') + # Get the text from function parameters until the return statement or function body beginning + # This text will include parameter declarations, any Solidity keywords and modifier call + # Parameter names cannot collide with modifier name per Solidity rules old_str_of_interest = in_file_str[int(function.parameters_src.source_mapping['start']): int(function.returns_src.source_mapping['start'])] + # Change the first letter of the modifier name (if present) to lowercase (new_str_of_interest, num_repl) = re.subn(name, name[0].lower()+name[1:], old_str_of_interest.decode('utf-8'),1) if num_repl != 0: @@ -277,8 +293,10 @@ def _create_patch_function_definition(format_info): if function.name == name: in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + # Search for the function name after the `function` keyword m = re.match(r'(.*)'+"function"+r'\s*'+name, old_str_of_interest.decode('utf-8')) old_str_of_interest = in_file_str[modify_loc_start:modify_loc_start+m.span()[1]] + # Change the first letter of the function name to lowercase (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"function"+r'(.*)'+name, r'\1'+"function"+r'\2'+ name[0].lower()+name[1:], old_str_of_interest.decode('utf-8'), 1) if num_repl != 0: @@ -303,17 +321,22 @@ def _create_patch_function_calls(format_info): for contract in slither.contracts: for function in contract.functions: for node in function.nodes: + # Function call from another contract for high_level_call in node.high_level_calls: if (high_level_call[0].name == contract_name and high_level_call[1].name == name): for external_call in node.external_calls_as_expressions: + # Check the called function name called_function = str(external_call.called).split('.')[-1] if called_function == high_level_call[1].name: in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[int(external_call.source_mapping['start']): int(external_call.source_mapping['start']) + int(external_call.source_mapping['length'])] + # Get the called function name. To-do: Check if we need to avoid parameters called_function_name = old_str_of_interest.decode('utf-8').split('.')[-1] + # Convert first letter of name to lowercase fixed_function_name = called_function_name[0].lower() + called_function_name[1:] + # Reconstruct the entire call new_string = '.'.join(old_str_of_interest.decode('utf-8').split('.')[:-1]) + '.' + \ fixed_function_name create_patch(patches, @@ -325,12 +348,14 @@ def _create_patch_function_calls(format_info): int(external_call.source_mapping['length']), old_str_of_interest.decode('utf-8'), new_string) + # Function call from within same contract for internal_call in node.internal_calls_as_expressions: if (str(internal_call.called) == name): in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[int(internal_call.source_mapping['start']): int(internal_call.source_mapping['start']) + int(internal_call.source_mapping['length'])] + # Get the called function name and avoid parameters old_str_of_interest = old_str_of_interest.decode('utf-8').split('(')[0] # Avoid parameters # TODO: (JF) review me @@ -361,11 +386,13 @@ def _create_patch_event_definition(format_info): raise SlitherException("Contract not found?!") for event in target_contract.events: if event.name == name: + # Get only event name without parameters event_name = name.split('(')[0] in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + # Capitalize event name (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"event"+r'(.*)'+event_name, r'\1'+"event"+r'\2' + - event_name[0].capitalize()+event_name[1:], + event_name.capitalize(), old_str_of_interest.decode('utf-8'), 1) if num_repl != 0: create_patch(patches, @@ -385,6 +412,7 @@ def _create_patch_event_calls(format_info): in_file, in_file_relative = format_info.in_file, format_info.in_file_relative contract_name = format_info.contract_name + # Get only event name without parameters event_name = name.split('(')[0] target_contract = slither.get_contract_from_name(contract_name) if not target_contract: @@ -406,8 +434,8 @@ def _create_patch_event_calls(format_info): call.source_mapping['start'], int(call.source_mapping['start']) + int(call.source_mapping['length']), old_str_of_interest.decode('utf-8'), - old_str_of_interest.decode('utf-8')[0].capitalize() + - old_str_of_interest.decode('utf-8')[1:]) + # Capitalize event name + old_str_of_interest.decode('utf-8').capitalize()) def _create_patch_parameter_declaration(format_info): @@ -424,12 +452,15 @@ def _create_patch_parameter_declaration(format_info): if function.name == function_name: in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + # To-do: Change format logic below - how do we convert a name to mixedCase? if(name[0] == '_'): + # If parameter name begins with underscore, capitalize the letter after underscore (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+name[0]+name[1].upper() + name[2:]+r'\2', old_str_of_interest.decode('utf-8'), 1) else: - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+'_'+name[0].upper() + - name[1:]+r'\2', old_str_of_interest.decode('utf-8'), 1) + # Add underscore and capitalize the first letter + (new_str_of_interest, num_repl) = re.subn(r'(.*)' + name + r'(.*)', r'\1' + '_' + name.capitalize() + + r'\2', old_str_of_interest.decode('utf-8'), 1) if num_repl != 0: create_patch(patches, "naming-convention (parameter declaration)", @@ -460,17 +491,23 @@ def _create_patch_parameter_uses(format_info): (node._local_vars_read + node._local_vars_written) if str(lv) == name]: + # Skip rare cases where source_mapping is absent. To-do: Investigate + if not v.source_mapping: + continue modify_loc_start = int(v.source_mapping['start']) modify_loc_end = int(v.source_mapping['start']) + int(v.source_mapping['length']) old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + # To-do: Change format logic below - how do we convert a name to mixedCase? if(name[0] == '_'): + # If parameter name begins with underscore, capitalize the letter after underscore (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+name[0]+name[1].upper()+name[2:] + r'\2', old_str_of_interest.decode('utf-8'), 1) else: + # Add underscore and capitalize the first letter (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+'_' + - name[0].upper()+name[1:]+r'\2', + name.capitalize()+r'\2', old_str_of_interest.decode('utf-8'), 1) if num_repl != 0: create_patch(patches, @@ -491,21 +528,26 @@ def _create_patch_parameter_uses(format_info): old_str_of_interest = in_file_str[modifier.source_mapping['start']: modifier.source_mapping['start'] + modifier.source_mapping['length']] + # Get text beyond modifier name which contains parameters old_str_of_interest_beyond_modifier_name = old_str_of_interest.decode('utf-8')\ .split('(')[1] + # To-do: Change format logic below - how do we convert a name to mixedCase? if(name[0] == '_'): + # If parameter name begins with underscore, capitalize the letter after underscore (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+name[0]+ name[1].upper()+name[2:]+r'\2', old_str_of_interest_beyond_modifier_name, 1) else: + # Add underscore and capitalize the first letter (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+'_'+ - name[0].upper()+name[1:]+r'\2', + name.capitalize()+r'\2', old_str_of_interest_beyond_modifier_name, 1) if num_repl != 0: create_patch(patches, "naming-convention (parameter uses)", in_file_relative, in_file, + # Start beyond modifier name which contains parameters modifier.source_mapping['start'] + len(old_str_of_interest.decode('utf-8').split('(')[0]) + 1, modifier.source_mapping['start'] + modifier.source_mapping['length'], @@ -533,8 +575,13 @@ def _create_patch_state_variable_declaration(format_info): in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + # Search for the state variable name and avoid the type m = re.search(name, old_str_of_interest.decode('utf-8')) + # Skip rare cases where re search fails. To-do: Investigate + if not m: + return if (_target == "variable_constant"): + # Convert constant state variables to upper case new_string = old_str_of_interest.decode('utf-8')[m.span()[0]:m.span()[1]].upper() else: new_string = old_str_of_interest.decode('utf-8')[m.span()[0]:m.span()[1]] @@ -544,6 +591,7 @@ def _create_patch_state_variable_declaration(format_info): "naming-convention (state variable declaration)", in_file_relative, in_file, + # Target only the state variable name and avoid the type modify_loc_start+m.span()[0], modify_loc_start+m.span()[1], old_str_of_interest.decode('utf-8')[m.span()[0]:m.span()[1]], @@ -576,6 +624,7 @@ def _create_patch_state_variable_uses(format_info): in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] if (_target == "variable_constant"): + # Convert constant state variables to upper case new_str_of_interest = old_str_of_interest.decode('utf-8').upper() else: new_str_of_interest = old_str_of_interest.decode('utf-8') @@ -609,6 +658,8 @@ def _create_patch_enum_definition(format_info): in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + # Search for the enum name after the `enum` keyword + # Capitalize enum name (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"enum"+r'(.*)'+name, r'\1'+"enum"+r'\2'+ name[0].capitalize()+name[1:], old_str_of_interest.decode('utf-8'), 1) @@ -682,23 +733,29 @@ def _create_patch_enum_uses(format_info): for ir in node.irs: if isinstance(ir, Member): if str(ir.variable_left) == name: + # Skip past the assignment old_str_of_interest = in_file_str[node.source_mapping['start']: (node.source_mapping['start']+ node.source_mapping['length'])].decode('utf-8')\ .split('=')[1] m = re.search(r'(.*)'+name, old_str_of_interest) + # Skip rare cases where re search fails. To-do: Investigate + if not m: + continue old_str_of_interest = old_str_of_interest[m.span()[0]:] - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name, r'\1'+name[0].upper()+name[1:], + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name, r'\1'+name.capitalize(), old_str_of_interest, 1) if num_repl != 0: # TODO (JF): review me + # Start past the assignment loc_start = node.source_mapping['start'] + \ len(in_file_str[node.source_mapping['start']: (node.source_mapping['start']+ node.source_mapping['length'])].decode('utf-8').split('=')[0]) + \ 1 + m.span()[0] + # End accounts for the assignment from the start loc_end = node.source_mapping['start'] +\ len(in_file_str[node.source_mapping['start']:(node.source_mapping['start']+ node.source_mapping['length'])].\ @@ -736,8 +793,9 @@ def _create_patch_struct_definition(format_info): in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + # Capitalize the struct name beyond the keyword `struct` (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"struct"+r'(.*)'+name, r'\1'+"struct"+r'\2'+ - name[0].capitalize()+name[1:], + name.capitalize(), old_str_of_interest.decode('utf-8'), 1) if num_repl != 0: create_patch(patches, diff --git a/utils/slither_format/formatters/pragma.py b/utils/slither_format/formatters/pragma.py index 4efe0820d..ebb0689f4 100644 --- a/utils/slither_format/formatters/pragma.py +++ b/utils/slither_format/formatters/pragma.py @@ -51,8 +51,10 @@ def _determine_solc_version_replacement(used_solc_version): version_right = versions[1] minor_version_right = '.'.join(version_right[2:])[2] if minor_version_right == '4': + # Replace with 0.4.25 return "pragma solidity " + REPLACEMENT_VERSIONS[0] + ';' elif minor_version_right in ['5', '6']: + # Replace with 0.5.3 return "pragma solidity " + REPLACEMENT_VERSIONS[1] + ';' diff --git a/utils/slither_format/formatters/solc_version.py b/utils/slither_format/formatters/solc_version.py index 2e7ca33c1..f03a96702 100644 --- a/utils/slither_format/formatters/solc_version.py +++ b/utils/slither_format/formatters/solc_version.py @@ -29,8 +29,10 @@ def _determine_solc_version_replacement(used_solc_version): version = versions[0] minor_version = '.'.join(version[2:])[2] if minor_version == '4': + # Replace with 0.4.25 return "pragma solidity " + REPLACEMENT_VERSIONS[0] + ';' elif minor_version == '5': + # Replace with 0.5.3 return "pragma solidity " + REPLACEMENT_VERSIONS[1] + ';' else: raise SlitherException("Unknown version!") @@ -38,8 +40,10 @@ def _determine_solc_version_replacement(used_solc_version): version_right = versions[1] minor_version_right = '.'.join(version_right[2:])[2] if minor_version_right == '4': + # Replace with 0.4.25 return "pragma solidity " + REPLACEMENT_VERSIONS[0] + ';' elif minor_version_right in ['5','6']: + # Replace with 0.5.3 return "pragma solidity " + REPLACEMENT_VERSIONS[1] + ';' diff --git a/utils/slither_format/formatters/unused_state.py b/utils/slither_format/formatters/unused_state.py index 8f874c679..c64f33190 100644 --- a/utils/slither_format/formatters/unused_state.py +++ b/utils/slither_format/formatters/unused_state.py @@ -21,6 +21,7 @@ def _patch(slither, patches, in_file, in_file_relative, modify_loc_start): in_file_relative, in_file, int(modify_loc_start), + # Remove the entire declaration until the semicolon int(modify_loc_start + len(old_str_of_interest.decode('utf-8').partition(';')[0]) + 1), old_str, "") diff --git a/utils/slither_format/slither_format.py b/utils/slither_format/slither_format.py index 7ca9db962..0f9292325 100644 --- a/utils/slither_format/slither_format.py +++ b/utils/slither_format/slither_format.py @@ -35,13 +35,21 @@ def slither_format(args, slither): 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 slither detector results on contract files to generate patches apply_detector_results(slither, patches, detector_results) + # Sort the patches in ascending order of the source mapping i.e. from beginning of contract file to end. + # Multiple detectors can produce alerts on same code fragments e.g. unused-state and constable-states. + # The current approach makes a single pass on the contract file to apply patches. + # Therefore, overlapping patches are ignored for now. Neither is applied. + # To-do: Prioritise one detector over another (via user input or hardcoded) for overlapping patches. sort_and_flag_overlapping_patches(patches) + # Remove overlapping 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) + print_patches(number_of_slither_results, patches) + # Generate git-compatible patch files generate_patch_files(slither, patches) def sort_and_flag_overlapping_patches(patches): From ed239cf970eb062d5494feb632585aa1103833d7 Mon Sep 17 00:00:00 2001 From: Josselin Date: Tue, 25 Jun 2019 11:39:45 +0200 Subject: [PATCH 065/223] Minor --- utils/slither_format/slither_format.py | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/utils/slither_format/slither_format.py b/utils/slither_format/slither_format.py index 49862ba92..c390f509d 100644 --- a/utils/slither_format/slither_format.py +++ b/utils/slither_format/slither_format.py @@ -107,19 +107,17 @@ def generate_patch_files(slither, patches): 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() logger.info("slither-format successful.") - logger.info("Created formatted file: " + _in_file+".format") + logger.info(f"Created formatted file: {_in_file}.format") patch_file_name = _in_file + ".format.patch" outFD = open(patch_file_name,"w") - logger.info(f'Output new file in {patch_file_name}') + logger.info(f'Created patch: {patch_file_name}') p1 = subprocess.Popen(['diff', '-u', _in_file, _in_file+".format"], stdout=outFD) p1.wait() outFD.close() - logger.info("Created patch file: " + patch_file_name) def print_patches(number_of_slither_results, patches): logger.info("Number of Slither results: " + str(number_of_slither_results)) From 0c7b22d50021d6eb09495435b540bce27cdbb2b0 Mon Sep 17 00:00:00 2001 From: Josselin Date: Tue, 25 Jun 2019 19:23:04 +0200 Subject: [PATCH 066/223] Update to crytic-compile 8539bc38e9f6efb94351ae8a21820bf5d205803e --- slither/__main__.py | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/slither/__main__.py b/slither/__main__.py index 01f3de96e..a71368e28 100644 --- a/slither/__main__.py +++ b/slither/__main__.py @@ -6,7 +6,6 @@ import inspect import json import logging import os -import subprocess import sys import traceback @@ -23,7 +22,7 @@ from slither.utils.colors import red, yellow, set_colorization_enabled from slither.utils.command_line import (output_detectors, output_results_to_markdown, output_detectors_json, output_printers, output_to_markdown, output_wiki) -from crytic_compile import CryticCompile +from crytic_compile import compile_all, is_supported from slither.exceptions import SlitherException logging.basicConfig() @@ -56,7 +55,7 @@ def process_single(target, args, detector_classes, printer_classes): def process_all(target, args, detector_classes, printer_classes): - compilations = CryticCompile.compile_all(target, **vars(args)) + compilations = compile_all(target, **vars(args)) results = [] analyzed_contracts_count = 0 for compilation in compilations: @@ -579,7 +578,7 @@ def main_impl(all_detector_classes, all_printer_classes): filename = args.filename # Determine if we are handling ast from solc - if args.solc_ast: + if args.solc_ast or (filename.endswith('.json') and not is_supported(filename)): globbed_filenames = glob.glob(filename, recursive=True) filenames = glob.glob(os.path.join(filename, "*.json")) if not filenames: From 341157f7e225d49c928d852507b41b03f6a0d8bd Mon Sep 17 00:00:00 2001 From: Josselin Date: Tue, 25 Jun 2019 21:17:46 +0200 Subject: [PATCH 067/223] source_mapping: Check for crytic_compile before acceding to it --- slither/core/source_mapping/source_mapping.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/slither/core/source_mapping/source_mapping.py b/slither/core/source_mapping/source_mapping.py index 8f922c05c..564b2f0e1 100644 --- a/slither/core/source_mapping/source_mapping.py +++ b/slither/core/source_mapping/source_mapping.py @@ -101,7 +101,7 @@ class SourceMapping(Context): else: filename = filename_used - if filename in slither.crytic_compile.src_content: + if slither.crytic_compile and filename in slither.crytic_compile.src_content: source_code = slither.crytic_compile.src_content[filename] (lines, starting_column, ending_column) = SourceMapping._compute_line(source_code, s, From 63a07f6ccdd1aaa5bbf3c680462ed5c224735baa Mon Sep 17 00:00:00 2001 From: Josselin Date: Wed, 26 Jun 2019 10:53:22 +0200 Subject: [PATCH 068/223] naming convention format: Factor together declaration/definition patch generation --- .../formatters/naming_convention.py | 309 ++++++++++-------- 1 file changed, 166 insertions(+), 143 deletions(-) diff --git a/utils/slither_format/formatters/naming_convention.py b/utils/slither_format/formatters/naming_convention.py index b7da90450..fcb3586d2 100644 --- a/utils/slither_format/formatters/naming_convention.py +++ b/utils/slither_format/formatters/naming_convention.py @@ -36,7 +36,7 @@ def format(slither, patches, elements): (element['source_mapping']['start'] + element['source_mapping']['length'])) elif target in ["modifier", "function", "event", - "variable", "variable_constant", "enum" + "variable", "variable_constant", "enum", "structure"]: _patch(slither, patches, @@ -76,66 +76,44 @@ def _patch(slither, patches, _target, name, function_name, contract_name, in_fil modify_loc_end) if _target == "contract": - _create_patch_contract_definition(format_info) - + _create_patch_declaration(format_info, _convert_contract_declaration) _create_patch_contract_uses(format_info) - elif _target == "structure": - _create_patch_struct_definition(format_info) + elif _target == "structure": + _create_patch_declaration(format_info, _convert_struct_definition) _create_patch_struct_uses(format_info) + elif _target == "event": _create_patch_event_definition(format_info) - _create_patch_event_calls(format_info) elif _target == "function": if name != contract_name: _create_patch_function_definition(format_info) - _create_patch_function_calls(format_info) + elif _target == "parameter": _create_patch_parameter_declaration(format_info) - _create_patch_parameter_uses(format_info) - elif _target in ["variable_constant", "variable"]: - _create_patch_state_variable_declaration(format_info) + elif _target == "variable": + _create_patch_declaration(format_info, _convert_state_variable_declaration) + _create_patch_state_variable_uses(format_info) + elif _target == "variable_constant": + _create_patch_declaration(format_info, _convert_state_variable_constant_declaration) _create_patch_state_variable_uses(format_info) + elif _target == "enum": - _create_patch_enum_definition(format_info) + _create_patch_declaration(format_info, _convert_enum_declaration) _create_patch_enum_uses(format_info) + elif _target == "modifier": _create_patch_modifier_definition(format_info) _create_patch_modifier_uses(format_info) - else: - raise SlitherException("Unknown naming convention! " + _target) - - - - -def _create_patch_contract_definition(format_info): - in_file_str = format_info.slither.source_code[format_info.in_file].encode('utf-8') - old_str_of_interest = in_file_str[format_info.loc_start:format_info.loc_end] - # Locate the name following keywords `contract` | `interface` | `library` - m = re.match(r'(.*)' + "(contract|interface|library)" + r'(.*)' + format_info.name, old_str_of_interest.decode('utf-8')) - old_str_of_interest = in_file_str[format_info.loc_start:format_info.loc_start+m.span()[1]] - # Capitalize the name - (new_str_of_interest, num_repl) = re.subn(r'(.*)' + r'(contract|interface|library)' + r'(.*)' + format_info.name, - r'\1' + r'\2' + r'\3' + format_info.name.capitalize(), - old_str_of_interest.decode('utf-8'), 1) - if num_repl != 0: - create_patch(format_info.patches, - "naming-convention (contract definition)", - format_info.in_file_relative, - format_info.in_file, - format_info.loc_start, - format_info.loc_start + m.span()[1], - old_str_of_interest.decode('utf-8'), - new_str_of_interest) else: - raise SlitherException("Could not find contract?!") + raise SlitherException("Unknown naming convention! " + _target) def _create_patch_contract_uses(format_info): @@ -557,46 +535,6 @@ def _create_patch_parameter_uses(format_info): raise SlitherException("Could not find parameter use in modifier?!") -def _create_patch_state_variable_declaration(format_info): - slither, patches, name = format_info.slither, format_info.patches, format_info.name - in_file, in_file_relative = format_info.in_file, format_info.in_file_relative - contract_name = format_info.contract_name - modify_loc_start, modify_loc_end = format_info.loc_start, format_info.loc_end - _target = format_info.target - - target_contract = slither.get_contract_from_name(contract_name) - if not target_contract: - raise SlitherException(f"Contract not found {contract_name}") - target_var = target_contract.get_state_variable_from_name(name) - if not target_var: - raise SlitherException(f"Contract not found {name}") - - # TODO (JF) target_var is not used, the above checks could be removed? - - in_file_str = slither.source_code[in_file].encode('utf-8') - old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - # Search for the state variable name and avoid the type - m = re.search(name, old_str_of_interest.decode('utf-8')) - # Skip rare cases where re search fails. To-do: Investigate - if not m: - return - if (_target == "variable_constant"): - # Convert constant state variables to upper case - new_string = old_str_of_interest.decode('utf-8')[m.span()[0]:m.span()[1]].upper() - else: - new_string = old_str_of_interest.decode('utf-8')[m.span()[0]:m.span()[1]] - new_string = new_string[0].lower()+new_string[1:] - - create_patch(patches, - "naming-convention (state variable declaration)", - in_file_relative, - in_file, - # Target only the state variable name and avoid the type - modify_loc_start+m.span()[0], - modify_loc_start+m.span()[1], - old_str_of_interest.decode('utf-8')[m.span()[0]:m.span()[1]], - new_string) - def _create_patch_state_variable_uses(format_info): slither, patches, name = format_info.slither, format_info.patches, format_info.name @@ -640,40 +578,7 @@ def _create_patch_state_variable_uses(format_info): new_str_of_interest) -def _create_patch_enum_definition(format_info): - slither, patches, name = format_info.slither, format_info.patches, format_info.name - in_file, in_file_relative = format_info.in_file, format_info.in_file_relative - contract_name = format_info.contract_name - modify_loc_start, modify_loc_end = format_info.loc_start, format_info.loc_end - - target_contract = slither.get_contract_from_name(contract_name) - if not target_contract: - raise SlitherException(f"Contract not found {contract_name}") - - target_enum = slither.get_enum_from_name(name) - if not target_enum: - raise SlitherException(f"Enum not found {name}") - # TODO (JF) target_enum is not used, the above checks could be removed? - - in_file_str = slither.source_code[in_file].encode('utf-8') - old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - # Search for the enum name after the `enum` keyword - # Capitalize enum name - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"enum"+r'(.*)'+name, r'\1'+"enum"+r'\2'+ - name[0].capitalize()+name[1:], - old_str_of_interest.decode('utf-8'), 1) - if num_repl != 0: - create_patch(patches, - "naming-convention (enum definition)", - in_file_relative, - in_file, - modify_loc_start, - modify_loc_end, - old_str_of_interest.decode('utf-8'), - new_str_of_interest) - else: - raise SlitherException("Could not find enum?!") def _create_patch_enum_uses(format_info): @@ -775,40 +680,7 @@ def _create_patch_enum_uses(format_info): # To-do: Check any other place/way where enum type is used -def _create_patch_struct_definition(format_info): - slither, patches, name = format_info.slither, format_info.patches, format_info.name - in_file, in_file_relative = format_info.in_file, format_info.in_file_relative - contract_name = format_info.contract_name - modify_loc_start, modify_loc_end = format_info.loc_start, format_info.loc_end - - target_contract = slither.get_contract_from_name(contract_name) - if not target_contract: - raise SlitherException(f"Contract not found {contract_name}") - - target_structure = slither.get_structure_from_name(name) - if not target_structure: - raise SlitherException(f"Structure not found {name}") - # TODO (JF) target_structure is not used, the above checks could be removed? - - in_file_str = slither.source_code[in_file].encode('utf-8') - old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - # Capitalize the struct name beyond the keyword `struct` - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"struct"+r'(.*)'+name, r'\1'+"struct"+r'\2'+ - name.capitalize(), - old_str_of_interest.decode('utf-8'), 1) - if num_repl != 0: - create_patch(patches, - "naming-convention (struct definition)", - in_file_relative, - in_file, - modify_loc_start, - modify_loc_end, - old_str_of_interest.decode('utf-8'), - new_str_of_interest) - - else: - raise SlitherException("Could not find struct?!") def _create_patch_struct_uses(format_info): @@ -860,3 +732,154 @@ def _create_patch_struct_uses(format_info): old_str_of_interest.decode('utf-8'), new_str_of_interest) # To-do: Check any other place/way where struct type is used (e.g. typecast) + + + + + +# endregion +################################################################################### +################################################################################### +# region Declaration +################################################################################### +################################################################################### + + +def _create_patch_declaration(format_info, convert_string): + slither, patches, name = format_info.slither, format_info.patches, format_info.name + in_file, in_file_relative = format_info.in_file, format_info.in_file_relative + modify_loc_start, modify_loc_end = format_info.loc_start, format_info.loc_end + + in_file_str = slither.source_code[in_file].encode('utf-8') + + + convert_res = convert_string(name, + in_file_str, + modify_loc_start, + modify_loc_end) + + if convert_res: + old_string, new_string, loc_start, loc_end, detector_name = convert_res + + create_patch(patches, + detector_name, + in_file_relative, + in_file, + loc_start, + loc_end, + old_string, + new_string) + +def _convert_contract_declaration(name, in_file_str, loc_start, loc_end): + old_str_of_interest = in_file_str[loc_start:loc_end] + # Locate the name following keywords `contract` | `interface` | `library` + m = re.match(r'(.*)' + "(contract|interface|library)" + r'(.*)' + name, old_str_of_interest.decode('utf-8')) + old_str_of_interest = in_file_str[loc_start:loc_start+m.span()[1]] + # Capitalize the name + (new_string, num_repl) = re.subn(r'(.*)' + r'(contract|interface|library)' + r'(.*)' + name, + r'\1' + r'\2' + r'\3' + name.capitalize(), + old_str_of_interest.decode('utf-8'), 1) + + if num_repl == 0: + raise SlitherException(f"Could not find contract: {name}") + + old_string = old_str_of_interest.decode('utf-8') + + loc_start = loc_start + loc_end = loc_start + m.span()[1] + + detector_name = "naming-convention (contract declaration)" + + return old_string, new_string, loc_start, loc_end, detector_name + + +def _convert_state_variable_declaration(name, in_file_str, loc_start, loc_end): + old_str_of_interest = in_file_str[loc_start:loc_end] + m = re.search(name, old_str_of_interest.decode('utf-8')) + # Skip rare cases where re search fails. To-do: Investigate + if not m: + return None + new_string = old_str_of_interest.decode('utf-8')[m.span()[0]:m.span()[1]] + new_string = new_string[0].lower() + new_string[1:] + + old_string = old_str_of_interest.decode('utf-8')[m.span()[0]:m.span()[1]] + + loc_start = loc_start + m.span()[0] + loc_end = loc_start + m.span()[1] + + detector_name = "naming-convention (state variable declaration)" + + return old_string, new_string, loc_start, loc_end, detector_name + + +def _convert_state_variable_constant_declaration(name, in_file_str, loc_start, loc_end): + old_str_of_interest = in_file_str[loc_start:loc_end] + m = re.search(name, old_str_of_interest.decode('utf-8')) + # Skip rare cases where re search fails. To-do: Investigate + if not m: + return None + # Convert constant state variables to upper case + new_string = old_str_of_interest.decode('utf-8')[m.span()[0]:m.span()[1]].upper() + + old_string = old_str_of_interest.decode('utf-8')[m.span()[0]:m.span()[1]] + + loc_start = loc_start + m.span()[0] + loc_end = loc_start + m.span()[1] + + detector_name = "naming-convention (state variable declaration)" + + return old_string, new_string, loc_start, loc_end, detector_name + + +def _convert_enum_declaration(name, in_file_str, loc_start, loc_end): + old_str_of_interest = in_file_str[loc_start:loc_end] + m = re.search(name, old_str_of_interest.decode('utf-8')) + # Skip rare cases where re search fails. To-do: Investigate + if not m: + return None + # Search for the enum name after the `enum` keyword + # Capitalize enum name + (new_string, num_repl) = re.subn(r'(.*)' + "enum" + r'(.*)' + name, r'\1' + "enum" + r'\2' + + name[0].capitalize() + name[1:], + old_str_of_interest.decode('utf-8'), 1) + + if num_repl == 0: + raise SlitherException(f"Could not find enum: {name}") + + old_string = old_str_of_interest.decode('utf-8') + + loc_start = loc_start + loc_end = loc_end + + detector_name = "naming-convention (enum declaration)" + + return old_string, new_string, loc_start, loc_end, detector_name + + +def _convert_struct_definition(name, in_file_str, loc_start, loc_end): + old_str_of_interest = in_file_str[loc_start:loc_end] + m = re.search(name, old_str_of_interest.decode('utf-8')) + # Skip rare cases where re search fails. To-do: Investigate + if not m: + return None + # Capitalize the struct name beyond the keyword `struct` + + (new_string, num_repl) = re.subn(r'(.*)'+"struct"+r'(.*)'+name, r'\1'+"struct"+r'\2'+ + name.capitalize(), + old_str_of_interest.decode('utf-8'), 1) + + if num_repl == 0: + raise SlitherException(f"Could not find struct: {name}") + + old_string = old_str_of_interest.decode('utf-8') + + loc_start = loc_start + loc_end = loc_end + + detector_name = "naming-convention (struct definition)" + + return old_string, new_string, loc_start, loc_end, detector_name + + + +# endregion \ No newline at end of file From 8fd5b9533a55ff8258c5c7cca217c9020902dc2a Mon Sep 17 00:00:00 2001 From: Josselin Date: Wed, 26 Jun 2019 11:52:01 +0200 Subject: [PATCH 069/223] Use difflib to generate patches (WIP) --- utils/slither_format/slither_format.py | 49 +++++++++++++++++--------- utils/slither_format/utils/patches.py | 22 ++++++++++-- 2 files changed, 51 insertions(+), 20 deletions(-) diff --git a/utils/slither_format/slither_format.py b/utils/slither_format/slither_format.py index c390f509d..bcfba7dbe 100644 --- a/utils/slither_format/slither_format.py +++ b/utils/slither_format/slither_format.py @@ -9,6 +9,7 @@ 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 import unused_state, constable_states, pragma, solc_version, external_function, naming_convention +from .utils.patches import apply_patch, create_diff logging.basicConfig(level=logging.INFO) logger = logging.getLogger('Slither.Format') @@ -27,30 +28,44 @@ all_detectors = { 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 slither detector results on contract files to generate patches apply_detector_results(slither, patches, detector_results) - # Sort the patches in ascending order of the source mapping i.e. from beginning of contract file to end. - # Multiple detectors can produce alerts on same code fragments e.g. unused-state and constable-states. - # The current approach makes a single pass on the contract file to apply patches. - # Therefore, overlapping patches are ignored for now. Neither is applied. - # To-do: Prioritise one detector over another (via user input or hardcoded) for overlapping patches. - sort_and_flag_overlapping_patches(patches) - # Remove overlapping 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 git-compatible patch files - generate_patch_files(slither, patches) + + counter = 0 + for file in patches: + for patch in patches[file]: + print(file) + print(patch['file']) + original_txt = slither.source_code[patch['file']] + patched_txt = apply_patch(original_txt, patch) + diff = create_diff(original_txt, patched_txt, file) + with open(f'patch_{counter}', 'w') as f: + f.write(diff) + + + + # # Sort the patches in ascending order of the source mapping i.e. from beginning of contract file to end. + # # Multiple detectors can produce alerts on same code fragments e.g. unused-state and constable-states. + # # The current approach makes a single pass on the contract file to apply patches. + # # Therefore, overlapping patches are ignored for now. Neither is applied. + # # To-do: Prioritise one detector over another (via user input or hardcoded) for overlapping patches. + # sort_and_flag_overlapping_patches(patches) + # # Remove overlapping 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 git-compatible patch files + # generate_patch_files(slither, patches) def sort_and_flag_overlapping_patches(patches): for file in patches: diff --git a/utils/slither_format/utils/patches.py b/utils/slither_format/utils/patches.py index 9c6803bf1..6a8898f0f 100644 --- a/utils/slither_format/utils/patches.py +++ b/utils/slither_format/utils/patches.py @@ -1,3 +1,4 @@ +import difflib def create_patch(patches, detector, file_relative, file, start, end, old_str, new_str): p = { @@ -8,7 +9,22 @@ def create_patch(patches, detector, file_relative, file, start, end, old_str, ne "old_string": old_str, "new_string": new_str } - if not file_relative in patches: - patches[file_relative] = [] if p not in patches[file_relative]: - patches[file_relative].append(p) \ No newline at end of file + patches[file_relative].append(p) + + +def apply_patch(original_txt, patch): + patched_txt = original_txt[:int(patch['start'])] + patched_txt += patch['new_string'] + patched_txt += original_txt[int(patch['end']):] + print(patched_txt) + return patched_txt + +def create_diff(original_txt, patched_txt, filename): + diff = difflib.unified_diff(original_txt.splitlines(False), + patched_txt.splitlines(False), + fromfile=filename, + tofile=filename, + lineterm='') + + return '\n'.join(list(diff)) + '\n' From e1c4ac6e6cc5ca3202995615557d1649a6bed2b2 Mon Sep 17 00:00:00 2001 From: Josselin Date: Wed, 26 Jun 2019 19:22:34 +0200 Subject: [PATCH 070/223] slither-format: - Remvoe patches dictionary, save result in standard detector json - Do not merge patches unrelated - generate patch with difflib - clean code, refactor naming convention --- utils/slither_format/__main__.py | 7 +- .../formatters/constable_states.py | 24 +- .../formatters/external_function.py | 16 +- .../formatters/naming_convention.py | 1257 ++++++++--------- utils/slither_format/formatters/pragma.py | 12 +- .../slither_format/formatters/solc_version.py | 13 +- .../slither_format/formatters/unused_state.py | 10 +- utils/slither_format/slither_format.py | 197 ++- utils/slither_format/utils/patches.py | 22 +- 9 files changed, 741 insertions(+), 817 deletions(-) diff --git a/utils/slither_format/__main__.py b/utils/slither_format/__main__.py index fdd1386f5..d2ebfacfa 100644 --- a/utils/slither_format/__main__.py +++ b/utils/slither_format/__main__.py @@ -35,6 +35,11 @@ def parse_args(): help='displays the current version', version='0.1.0', action='version') + + parser.add_argument('--skip-patch-generation', + help='Do not generate patch files', + action='store_true', + default=False) group_detector = parser.add_argument_group('Detectors') group_detector.add_argument('--detect', @@ -66,6 +71,6 @@ def main(): slither = Slither(args.filename, **vars(args)) # Format the input files based on slither analysis - slither_format(args, slither) + slither_format(slither, **vars(args)) if __name__ == '__main__': main() diff --git a/utils/slither_format/formatters/constable_states.py b/utils/slither_format/formatters/constable_states.py index a274633eb..aa275bdf6 100644 --- a/utils/slither_format/formatters/constable_states.py +++ b/utils/slither_format/formatters/constable_states.py @@ -2,32 +2,28 @@ import re from slither.exceptions import SlitherException from ..utils.patches import create_patch -def format(slither, patches, elements): +def format(slither, result): + elements = result['elements'] for element in elements: - _patch(slither, patches, element['source_mapping']['filename_absolute'], - element['source_mapping']['filename_relative'], + _patch(slither, result, element['source_mapping']['filename_absolute'], element['name'], "constant " + element['name'], element['source_mapping']['start'], element['source_mapping']['start'] + element['source_mapping']['length']) -def _patch(slither, patches, in_file, in_file_relative, match_text, replace_text, modify_loc_start, modify_loc_end): +def _patch(slither, result, in_file, match_text, replace_text, modify_loc_start, modify_loc_end): in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] # Add keyword `constant` before the variable name (new_str_of_interest, num_repl) = re.subn(match_text, replace_text, old_str_of_interest.decode('utf-8'), 1) if num_repl != 0: - create_patch( - patches, - "constable-states", - in_file_relative, - in_file, - modify_loc_start, - modify_loc_end, - old_str_of_interest.decode('utf-8'), - new_str_of_interest - ) + create_patch(result, + in_file, + modify_loc_start, + modify_loc_end, + old_str_of_interest.decode('utf-8'), + new_str_of_interest) else: raise SlitherException("State variable not found?!") diff --git a/utils/slither_format/formatters/external_function.py b/utils/slither_format/formatters/external_function.py index 1da1d7ea7..28db15f24 100644 --- a/utils/slither_format/formatters/external_function.py +++ b/utils/slither_format/formatters/external_function.py @@ -1,21 +1,21 @@ import re from ..utils.patches import create_patch -def format(slither, patches, elements): +def format(slither, result): + elements = result['elements'] for element in elements: target_contract = slither.get_contract_from_name(element['type_specific_fields']['parent']['name']) if target_contract: for function in target_contract.functions: if function.name == element['name']: - _patch(slither, patches, + _patch(slither, result, element['source_mapping']['filename_absolute'], - element['source_mapping']['filename_relative'], int(function.parameters_src.source_mapping['start']), int(function.returns_src.source_mapping['start'])) break -def _patch(slither, patches, in_file, in_file_relative, modify_loc_start, modify_loc_end): +def _patch(slither, result, in_file, modify_loc_start, modify_loc_end): in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] # Search for 'public' keyword which is in-between the function name and modifier name (if present) @@ -23,9 +23,7 @@ def _patch(slither, patches, in_file, in_file_relative, modify_loc_start, modify m = re.search(r'((\spublic)\s+)|(\spublic)$|(\)public)$', old_str_of_interest.decode('utf-8')) if m is None: # No visibility specifier exists; public by default. - create_patch(patches, - "external-function", - in_file_relative, + create_patch(result, in_file, # start after the function definition's closing paranthesis modify_loc_start + len(old_str_of_interest.decode('utf-8').split(')')[0]) + 1, @@ -34,9 +32,7 @@ def _patch(slither, patches, in_file, in_file_relative, modify_loc_start, modify "", " external") # replace_text is `external` else: - create_patch(patches, - "external-function", - in_file_relative, + create_patch(result, in_file, # start at the keyword `public` modify_loc_start + m.span()[0] + 1, diff --git a/utils/slither_format/formatters/naming_convention.py b/utils/slither_format/formatters/naming_convention.py index fcb3586d2..761aa13d3 100644 --- a/utils/slither_format/formatters/naming_convention.py +++ b/utils/slither_format/formatters/naming_convention.py @@ -1,4 +1,5 @@ import re +import logging from collections import namedtuple from slither.exceptions import SlitherException from slither.core.expressions.identifier import Identifier @@ -6,295 +7,463 @@ from slither.slithir.operations import NewContract from slither.slithir.operations import Member from ..utils.patches import create_patch -# The Namedtuple will be used to give all the parameters from _patch to the _create_X functions -# Its used to improve code readability and avoid incorrect parameters order -FormatInfo = namedtuple("FormatInfo", ["slither", - "patches", - "target", - "name", - "function_name", - "contract_name", - "in_file", - "in_file_relative", - "loc_start", - "loc_end"]) - - -def format(slither, patches, elements): +logging.basicConfig(level=logging.INFO) +logger = logging.getLogger('Slither.Format') + +def format(slither, result): + elements = result['elements'] for element in elements: target = element['additional_fields']['target'] - if (target == "parameter"): - _patch(slither, - patches, - element['additional_fields']['target'], - element['name'], - element['type_specific_fields']['parent']['name'], - element['type_specific_fields']['parent']['type_specific_fields']['parent']['name'], - element['source_mapping']['filename_absolute'], - element['source_mapping']['filename_relative'], - element['source_mapping']['start'], - (element['source_mapping']['start'] + element['source_mapping']['length'])) - - elif target in ["modifier", "function", "event", - "variable", "variable_constant", "enum", - "structure"]: - _patch(slither, - patches, - target, - element['name'], - element['name'], - element['type_specific_fields']['parent']['name'], - element['source_mapping']['filename_absolute'], - element['source_mapping']['filename_relative'], - element['source_mapping']['start'], - (element['source_mapping']['start'] + element['source_mapping']['length'])) - else: - _patch(slither, - patches, - element['additional_fields']['target'], - element['name'], - element['name'], - element['name'], - element['source_mapping']['filename_absolute'], - element['source_mapping']['filename_relative'], - element['source_mapping']['start'], - (element['source_mapping']['start'] + element['source_mapping']['length'])) - - -def _patch(slither, patches, _target, name, function_name, contract_name, in_file, in_file_relative, - modify_loc_start, modify_loc_end): - - format_info = FormatInfo(slither, - patches, - _target, - name, - function_name, - contract_name, - in_file, - in_file_relative, - modify_loc_start, - modify_loc_end) + + convention = element['additional_fields']['convention'] + + if convention == "l_O_I_should_not_be_used": + # l_O_I_should_not_be_used cannot be automatically patched + logger.info(f'The following naming convention cannot be patched: \n{result["description"]}') + continue + + _patch(slither, result, element, target) + +# endregion +################################################################################### +################################################################################### +# region Helpers +################################################################################### +################################################################################### + +def _unpack_info(slither, element): + path = element['source_mapping']['filename_absolute'] + source_code = slither.source_code[path].encode('utf-8') + + loc_start = element['source_mapping']['start'] + loc_end = loc_start + element['source_mapping']['length'] + old_string = source_code[loc_start:loc_end] + return path, source_code, old_string, loc_start, loc_end + +def get_name(element): + return element['name'] + +def get_contract_name(element): + target = element['additional_fields']['target'] + if target == "parameter": + return element['type_specific_fields']['parent']['type_specific_fields']['parent']['name'] + elif target in ["modifier", "function", "event", + "variable", "variable_constant", "enum", + "structure"]: + return element['type_specific_fields']['parent']['name'] + return element['name'] + + +# endregion +################################################################################### +################################################################################### +# region Patch dispatcher +################################################################################### +################################################################################### + +def _patch(slither, result, element, _target): if _target == "contract": - _create_patch_declaration(format_info, _convert_contract_declaration) - _create_patch_contract_uses(format_info) + _create_patch_contract_definition(slither, result, element) + _create_patch_contract_uses(slither, result, element) elif _target == "structure": - _create_patch_declaration(format_info, _convert_struct_definition) - _create_patch_struct_uses(format_info) + _create_patch_struct_definition(slither, result, element) + _create_patch_struct_uses(slither, result, element) elif _target == "event": - _create_patch_event_definition(format_info) - _create_patch_event_calls(format_info) + _create_patch_event_definition(slither, result, element) + _create_patch_event_calls(slither, result, element) elif _target == "function": - if name != contract_name: - _create_patch_function_definition(format_info) - _create_patch_function_calls(format_info) + # Avoid constructor (FP?) + if element['name'] != element['type_specific_fields']['parent']['name']: + _create_patch_function_definition(slither, result, element) + _create_patch_function_calls(slither, result, element) elif _target == "parameter": - _create_patch_parameter_declaration(format_info) - _create_patch_parameter_uses(format_info) + _create_patch_parameter_declaration(slither, result, element) + _create_patch_parameter_uses(slither, result, element) elif _target == "variable": - _create_patch_declaration(format_info, _convert_state_variable_declaration) - _create_patch_state_variable_uses(format_info) + _create_patch_state_variable_declaration(slither, result, element) + _create_patch_state_variable_uses(slither, result, element) elif _target == "variable_constant": - _create_patch_declaration(format_info, _convert_state_variable_constant_declaration) - _create_patch_state_variable_uses(format_info) + _create_patch_state_variable_constant_declaration(slither, result, element) + _create_patch_state_variable_uses(slither, result, element) elif _target == "enum": - _create_patch_declaration(format_info, _convert_enum_declaration) - _create_patch_enum_uses(format_info) + _create_patch_enum_declaration(slither, result, element) + _create_patch_enum_uses(slither, result, element) elif _target == "modifier": - _create_patch_modifier_definition(format_info) - _create_patch_modifier_uses(format_info) + _create_patch_modifier_definition(slither, result, element) + _create_patch_modifier_uses(slither, result, element) else: raise SlitherException("Unknown naming convention! " + _target) +# endregion +################################################################################### +################################################################################### +# region Declaration and Definition +################################################################################### +################################################################################### -def _create_patch_contract_uses(format_info): - slither, patches, name = format_info.slither, format_info.patches, format_info.name - in_file, in_file_relative = format_info.in_file, format_info.in_file_relative - for contract in slither.contracts: - # Ignore contract definition - if contract.name != name: - in_file_str = slither.source_code[in_file].encode('utf-8') - # Check state variables of contract type - # To-do: Deep-check aggregate types (struct and mapping) - svs = contract.variables - for sv in svs: - if (str(sv.type) == name): - old_str_of_interest = in_file_str[sv.source_mapping['start']:(sv.source_mapping['start'] + - sv.source_mapping['length'])] - # Get only the contract variable name even if it is initialised - (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(), - old_str_of_interest.decode('utf-8'), 1) - create_patch(patches, - "naming-convention (contract state variable)", - in_file_relative, - in_file, - sv.source_mapping['start'], - sv.source_mapping['start'] + sv.source_mapping['length'], - old_str_of_interest.decode('utf-8'), - new_str_of_interest) - # Check function+modifier locals+parameters+returns - # To-do: Deep-check aggregate types (struct and mapping) - fms = contract.functions + contract.modifiers - for fm in fms: - for v in fm.variables: - if (str(v.type) == name): - old_str_of_interest = in_file_str[v.source_mapping['start']:(v.source_mapping['start'] + - v.source_mapping['length'])] - old_str_of_interest = old_str_of_interest.decode('utf-8').split('=')[0] - (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(),old_str_of_interest, 1) - - create_patch(patches, - "naming-convention (contract function variable)", - in_file_relative, - in_file, - v.source_mapping['start'], - v.source_mapping['start'] + len(old_str_of_interest), - old_str_of_interest, - new_str_of_interest) +def _create_patch_contract_definition(slither, result, element): + in_file, in_file_str, old_str_of_interest, loc_start, loc_end = _unpack_info(slither, element) - # Check "new" expressions for creation of contract objects - for function in contract.functions: - for node in function.nodes: - for ir in node.irs: - if isinstance(ir, NewContract) and ir.contract_name == name: - old_str_of_interest = in_file_str[node.source_mapping['start']:node.source_mapping['start'] + - node.source_mapping['length']] - # Search for the name after the `new` keyword - m = re.search("new"+r'(.*)'+name, old_str_of_interest.decode('utf-8')) - # Skip rare cases where re search fails. To-do: Investigate - if not m: - continue - old_str_of_interest = old_str_of_interest.decode('utf-8')[m.span()[0]:] - (new_str_of_interest, num_repl) = re.subn("new" + r'(.*)' + format_info.name, - "new" + r'\1' + format_info.name.capitalize(), - format_info.name[1:], old_str_of_interest, 1) - if num_repl != 0: - create_patch(patches, - "naming-convention (contract new object)", - in_file_relative, - in_file, - # start after the `new` keyword where the name begins - node.source_mapping['start'] + m.span()[0], - node.source_mapping['start'] + m.span()[1], - old_str_of_interest, - new_str_of_interest) - else: - raise SlitherException("Could not find new object?!") + name = get_name(element) + + # Locate the name following keywords `contract` | `interface` | `library` + m = re.match(r'(.*)' + "(contract|interface|library)" + r'(.*)' + name, old_str_of_interest.decode('utf-8')) + + old_str_of_interest = in_file_str[loc_start:loc_start+m.span()[1]] + # Capitalize the name + (new_string, num_repl) = re.subn(r'(.*)' + r'(contract|interface|library)' + r'(.*)' + name, + r'\1' + r'\2' + r'\3' + name.capitalize(), + old_str_of_interest.decode('utf-8'), 1) + + if num_repl == 0: + raise SlitherException(f"Could not find contract: {name}") + old_string = old_str_of_interest.decode('utf-8') + + loc_end = loc_start + m.span()[1] + + create_patch(result, + in_file, + loc_start, + loc_end, + old_string, + new_string) + + +def _create_patch_state_variable_declaration(slither, result, element): + in_file, in_file_str, old_str_of_interest, loc_start, loc_end = _unpack_info(slither, element) + + name = get_name(element) + + m = re.search(name, old_str_of_interest.decode('utf-8')) + # Skip rare cases where re search fails. To-do: Investigate + if not m: + return None + new_string = old_str_of_interest.decode('utf-8')[m.span()[0]:m.span()[1]] + new_string = new_string[0].lower() + new_string[1:] + + old_string = old_str_of_interest.decode('utf-8')[m.span()[0]:m.span()[1]] + + loc_end = loc_start + m.span()[1] + loc_start = loc_start + m.span()[0] + + create_patch(result, + in_file, + loc_start, + loc_end, + old_string, + new_string) -def _create_patch_modifier_definition(format_info): - slither, patches, name = format_info.slither, format_info.patches, format_info.name - in_file, in_file_relative = format_info.in_file, format_info.in_file_relative - contract_name = format_info.contract_name - modify_loc_start, modify_loc_end = format_info.loc_start, format_info.loc_end + +def _create_patch_state_variable_constant_declaration(slither, result, element): + in_file, in_file_str, old_str_of_interest, loc_start, _ = _unpack_info(slither, element) + + name = get_name(element) + + m = re.search(name, old_str_of_interest.decode('utf-8')) + # Skip rare cases where re search fails. To-do: Investigate + if not m: + return None + # Convert constant state variables to upper case + new_string = old_str_of_interest.decode('utf-8')[m.span()[0]:m.span()[1]].upper() + + old_string = old_str_of_interest.decode('utf-8')[m.span()[0]:m.span()[1]] + loc_end = loc_start + m.span()[1] + loc_start = loc_start + m.span()[0] + + create_patch(result, + in_file, + loc_start, + loc_end, + old_string, + new_string) + + +def _create_patch_enum_declaration(slither, result, element): + in_file, in_file_str, old_str_of_interest, loc_start, loc_end = _unpack_info(slither, element) + + name = get_name(element) + + m = re.search(name, old_str_of_interest.decode('utf-8')) + # Skip rare cases where re search fails. To-do: Investigate + if not m: + return None + # Search for the enum name after the `enum` keyword + # Capitalize enum name + (new_string, num_repl) = re.subn(r'(.*)' + "enum" + r'(.*)' + name, r'\1' + "enum" + r'\2' + + name[0].capitalize() + name[1:], + old_str_of_interest.decode('utf-8'), 1) + + if num_repl == 0: + raise SlitherException(f"Could not find enum: {name}") + + old_string = old_str_of_interest.decode('utf-8') + + create_patch(result, + in_file, + loc_start, + loc_end, + old_string, + new_string) + + +def _create_patch_struct_definition(slither, result, element): + in_file, in_file_str, old_str_of_interest, loc_start, loc_end = _unpack_info(slither, element) + + name = get_name(element) + + m = re.search(name, old_str_of_interest.decode('utf-8')) + # Skip rare cases where re search fails. To-do: Investigate + if not m: + return None + # Capitalize the struct name beyond the keyword `struct` + + (new_string, num_repl) = re.subn(r'(.*)'+"struct"+r'(.*)'+name, r'\1'+"struct"+r'\2'+ + name.capitalize(), + old_str_of_interest.decode('utf-8'), 1) + + if num_repl == 0: + raise SlitherException(f"Could not find struct: {name}") + + old_string = old_str_of_interest.decode('utf-8') + + create_patch(result, + in_file, + loc_start, + loc_end, + old_string, + new_string) + + +def _create_patch_modifier_definition(slither, result, element): + in_file, in_file_str, old_str_of_interest, loc_start, loc_end = _unpack_info(slither, element) + name = get_name(element) + + in_file_str = slither.source_code[in_file].encode('utf-8') + old_str_of_interest = in_file_str[loc_start:loc_end] + # Search for the modifier name after the `modifier` keyword + m = re.match(r'(.*)'+"modifier"+r'(.*)'+name, old_str_of_interest.decode('utf-8')) + old_str_of_interest = in_file_str[loc_start:loc_end+m.span()[1]] + # Change the first letter of the modifier name to lowercase + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"modifier"+r'(.*)'+name, r'\1'+"modifier"+r'\2' + + name[0].lower()+name[1:], old_str_of_interest.decode('utf-8'), 1) + if num_repl != 0: + create_patch(result, + in_file, + loc_start, + loc_end + m.span()[1], + old_str_of_interest.decode('utf-8'), + new_str_of_interest) + else: + raise SlitherException("Could not find modifier?!") + + +def _create_patch_function_definition(slither, result, element): + in_file, in_file_str, old_str_of_interest, loc_start, loc_end = _unpack_info(slither, element) + name = get_name(element) + + in_file_str = slither.source_code[in_file].encode('utf-8') + old_str_of_interest = in_file_str[loc_start:loc_end] + # Search for the function name after the `function` keyword + m = re.match(r'(.*)'+"function"+r'\s*'+name, old_str_of_interest.decode('utf-8')) + old_str_of_interest = in_file_str[loc_start:loc_start+m.span()[1]] + # Change the first letter of the function name to lowercase + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"function"+r'(.*)'+name, r'\1'+"function"+r'\2'+ + name[0].lower()+name[1:], old_str_of_interest.decode('utf-8'), 1) + if num_repl != 0: + create_patch(result, + in_file, + loc_start, + loc_start+m.span()[1], + old_str_of_interest.decode('utf-8'), + new_str_of_interest) + + else: + raise SlitherException(f"Could not find function {name}") + +def _create_patch_event_definition(slither, result, element): + in_file, in_file_str, old_str_of_interest, loc_start, loc_end = _unpack_info(slither, element) + + name = get_name(element) + contract_name = get_contract_name(element) target_contract = slither.get_contract_from_name(contract_name) if not target_contract: raise SlitherException("Contract not found?!") - for modifier in target_contract.modifiers: - if modifier.name == name: + for event in target_contract.events: + if event.name == name: + # Get only event name without parameters + event_name = name.split('(')[0] in_file_str = slither.source_code[in_file].encode('utf-8') - old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - # Search for the modifier name after the `modifier` keyword - m = re.match(r'(.*)'+"modifier"+r'(.*)'+name, old_str_of_interest.decode('utf-8')) - old_str_of_interest = in_file_str[modify_loc_start:modify_loc_start+m.span()[1]] - # Change the first letter of the modifier name to lowercase - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"modifier"+r'(.*)'+name, r'\1'+"modifier"+r'\2' + - name[0].lower()+name[1:], old_str_of_interest.decode('utf-8'), 1) + old_str_of_interest = in_file_str[loc_start:loc_end] + # Capitalize event name + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"event"+r'(.*)'+event_name, r'\1'+"event"+r'\2' + + event_name.capitalize(), + old_str_of_interest.decode('utf-8'), 1) if num_repl != 0: - create_patch(patches, - "naming-convention (modifier definition)", - in_file_relative, + create_patch(result, in_file, - modify_loc_start, - modify_loc_start + m.span()[1], + loc_start, + loc_end, old_str_of_interest.decode('utf-8'), new_str_of_interest) else: - raise SlitherException("Could not find modifier?!") + raise SlitherException("Could not find event?!") +def _create_patch_parameter_declaration(slither, result, element): + in_file, in_file_str, old_str_of_interest, loc_start, loc_end = _unpack_info(slither, element) + name = get_name(element) -def _create_patch_modifier_uses(format_info): - slither, patches, name = format_info.slither, format_info.patches, format_info.name - in_file, in_file_relative = format_info.in_file, format_info.in_file_relative - contract_name = format_info.contract_name + # To-do: Change format logic below - how do we convert a name to mixedCase? + if(name[0] == '_'): + # If parameter name begins with underscore, capitalize the letter after underscore + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+name[0]+name[1].upper() + + name[2:]+r'\2', old_str_of_interest.decode('utf-8'), 1) + else: + # Add underscore and capitalize the first letter + (new_str_of_interest, num_repl) = re.subn(r'(.*)' + name + r'(.*)', r'\1' + '_' + name.capitalize() + + r'\2', old_str_of_interest.decode('utf-8'), 1) + if num_repl != 0: + create_patch(result, + in_file, + loc_start, + loc_end, + old_str_of_interest.decode('utf-8'), + new_str_of_interest) + else: + raise SlitherException("Could not find parameter declaration?!") - target_contract = slither.get_contract_from_name(contract_name) +# endregion +################################################################################### +################################################################################### +# region Usage patches +################################################################################### +################################################################################### + +def _create_patch_contract_uses(slither, result, element): + in_file, in_file_str, old_str_of_interest, loc_start, loc_end = _unpack_info(slither, element) + + name = get_name(element) + + target_contract = slither.get_contract_from_name(name) if not target_contract: - raise SlitherException("Contract not found?!") - for contract in [target_contract] + target_contract.derived_contracts: - for function in contract.functions: - for m in function.modifiers: - if (m.name == name): - in_file_str = slither.source_code[in_file].encode('utf-8') - # Get the text from function parameters until the return statement or function body beginning - # This text will include parameter declarations, any Solidity keywords and modifier call - # Parameter names cannot collide with modifier name per Solidity rules - old_str_of_interest = in_file_str[int(function.parameters_src.source_mapping['start']): - int(function.returns_src.source_mapping['start'])] - # Change the first letter of the modifier name (if present) to lowercase - (new_str_of_interest, num_repl) = re.subn(name, name[0].lower()+name[1:], - old_str_of_interest.decode('utf-8'),1) + raise SlitherException(f"Contract not found {name}") + + # Check state variables of contract type + # To-do: Deep-check aggregate types (struct and mapping) + svs = target_contract.variables + for sv in svs: + if (str(sv.type) == name): + old_str_of_interest = in_file_str[sv.source_mapping['start']:(sv.source_mapping['start'] + + sv.source_mapping['length'])] + # Get only the contract variable name even if it is initialised + (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(), + old_str_of_interest.decode('utf-8'), 1) + create_patch(result, + in_file, + sv.source_mapping['start'], + sv.source_mapping['start'] + sv.source_mapping['length'], + old_str_of_interest.decode('utf-8'), + new_str_of_interest) + # Check function+modifier locals+parameters+returns + # To-do: Deep-check aggregate types (struct and mapping) + fms = target_contract.functions + target_contract.modifiers + for fm in fms: + for v in fm.variables: + if (str(v.type) == name): + old_str_of_interest = in_file_str[v.source_mapping['start']:(v.source_mapping['start'] + + v.source_mapping['length'])] + old_str_of_interest = old_str_of_interest.decode('utf-8').split('=')[0] + (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(),old_str_of_interest, 1) + + create_patch(result, + in_file, + v.source_mapping['start'], + v.source_mapping['start'] + len(old_str_of_interest), + old_str_of_interest, + new_str_of_interest) + + # Check "new" expressions for creation of contract objects + for function in target_contract.functions: + for node in function.nodes: + for ir in node.irs: + if isinstance(ir, NewContract) and ir.contract_name == name: + old_str_of_interest = in_file_str[node.source_mapping['start']:node.source_mapping['start'] + + node.source_mapping['length']] + # Search for the name after the `new` keyword + m = re.search("new"+r'(.*)'+name, old_str_of_interest.decode('utf-8')) + # Skip rare cases where re search fails. To-do: Investigate + if not m: + continue + old_str_of_interest = old_str_of_interest.decode('utf-8')[m.span()[0]:] + (new_str_of_interest, num_repl) = re.subn("new" + r'(.*)' + name, + "new" + r'\1' + name.capitalize(), + name[1:], old_str_of_interest, 1) if num_repl != 0: - create_patch(patches, - "naming-convention (modifier uses)", - in_file_relative, + create_patch(result, in_file, - int(function.parameters_src.source_mapping['start']), - int(function.returns_src.source_mapping['start']), - old_str_of_interest.decode('utf-8'), + # start after the `new` keyword where the name begins + node.source_mapping['start'] + m.span()[0], + node.source_mapping['start'] + m.span()[1], + old_str_of_interest, new_str_of_interest) else: - raise SlitherException("Could not find modifier name?!") + raise SlitherException("Could not find new object?!") + +def _create_patch_modifier_uses(slither, result, element): + in_file, in_file_str, old_str_of_interest, loc_start, loc_end = _unpack_info(slither, element) -def _create_patch_function_definition(format_info): - slither, patches, name = format_info.slither, format_info.patches, format_info.name - in_file, in_file_relative = format_info.in_file, format_info.in_file_relative - contract_name = format_info.contract_name - modify_loc_start, modify_loc_end = format_info.loc_start, format_info.loc_end + name = get_name(element) + contract_name = get_contract_name(element) + + modifier_sig = element['type_specific_fields']['signature'] target_contract = slither.get_contract_from_name(contract_name) if not target_contract: raise SlitherException("Contract not found?!") + + modifier_contract = target_contract.get_modifier_from_signature(modifier_sig) + for function in target_contract.functions: - if function.name == name: - in_file_str = slither.source_code[in_file].encode('utf-8') - old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - # Search for the function name after the `function` keyword - m = re.match(r'(.*)'+"function"+r'\s*'+name, old_str_of_interest.decode('utf-8')) - old_str_of_interest = in_file_str[modify_loc_start:modify_loc_start+m.span()[1]] - # Change the first letter of the function name to lowercase - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"function"+r'(.*)'+name, r'\1'+"function"+r'\2'+ - name[0].lower()+name[1:], old_str_of_interest.decode('utf-8'), 1) - if num_repl != 0: - create_patch(patches, - "naming-convention (function definition)", - in_file_relative, - in_file, - modify_loc_start, - modify_loc_start+m.span()[1], - old_str_of_interest.decode('utf-8'), - new_str_of_interest) + for m in function.modifiers: + if (m == modifier_contract): + in_file_str = slither.source_code[in_file].encode('utf-8') + # Get the text from function parameters until the return statement or function body beginning + # This text will include parameter declarations, any Solidity keywords and modifier call + # Parameter names cannot collide with modifier name per Solidity rules + old_str_of_interest = in_file_str[int(function.parameters_src.source_mapping['start']): + int(function.returns_src.source_mapping['start'])] + # Change the first letter of the modifier name (if present) to lowercase + (new_str_of_interest, num_repl) = re.subn(name, name[0].lower()+name[1:], + old_str_of_interest.decode('utf-8'),1) + if num_repl != 0: + create_patch(result, + in_file, + int(function.parameters_src.source_mapping['start']), + int(function.returns_src.source_mapping['start']), + old_str_of_interest.decode('utf-8'), + new_str_of_interest) + else: + raise SlitherException("Could not find modifier name?!") - else: - raise SlitherException("Could not find function?!") -def _create_patch_function_calls(format_info): - slither, patches, name = format_info.slither, format_info.patches, format_info.name - in_file, in_file_relative = format_info.in_file, format_info.in_file_relative - contract_name = format_info.contract_name +def _create_patch_function_calls(slither, result, element): + in_file, in_file_str, old_str_of_interest, loc_start, loc_end = _unpack_info(slither, element) + name = get_name(element) + contract_name = get_contract_name(element) for contract in slither.contracts: for function in contract.functions: @@ -317,9 +486,7 @@ def _create_patch_function_calls(format_info): # Reconstruct the entire call new_string = '.'.join(old_str_of_interest.decode('utf-8').split('.')[:-1]) + '.' + \ fixed_function_name - create_patch(patches, - "naming-convention (function calls)", - in_file_relative, + create_patch(result, in_file, external_call.source_mapping['start'], int(external_call.source_mapping['start']) + @@ -343,9 +510,7 @@ def _create_patch_function_calls(format_info): int(internal_call.source_mapping['start']) + int(internal_call.source_mapping['length'])] \ .decode('utf-8').split('(')[1:])) - 1 - create_patch(patches, - "naming-convention (function calls)", - in_file_relative, + create_patch(result, in_file, internal_call.source_mapping['start'], end_loc, @@ -353,42 +518,13 @@ def _create_patch_function_calls(format_info): old_str_of_interest[0].lower()+old_str_of_interest[1:]) -def _create_patch_event_definition(format_info): - slither, patches, name = format_info.slither, format_info.patches, format_info.name - in_file, in_file_relative = format_info.in_file, format_info.in_file_relative - contract_name = format_info.contract_name - modify_loc_start, modify_loc_end = format_info.loc_start, format_info.loc_end - target_contract = slither.get_contract_from_name(contract_name) - if not target_contract: - raise SlitherException("Contract not found?!") - for event in target_contract.events: - if event.name == name: - # Get only event name without parameters - event_name = name.split('(')[0] - in_file_str = slither.source_code[in_file].encode('utf-8') - old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - # Capitalize event name - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"event"+r'(.*)'+event_name, r'\1'+"event"+r'\2' + - event_name.capitalize(), - old_str_of_interest.decode('utf-8'), 1) - if num_repl != 0: - create_patch(patches, - "naming-convention (event definition)", - in_file_relative, - in_file, - modify_loc_start, - modify_loc_end, - old_str_of_interest.decode('utf-8'), - new_str_of_interest) - else: - raise SlitherException("Could not find event?!") +def _create_patch_event_calls(slither, result, element): + in_file, in_file_str, old_str_of_interest, loc_start, loc_end = _unpack_info(slither, element) -def _create_patch_event_calls(format_info): - slither, patches, name = format_info.slither, format_info.patches, format_info.name - in_file, in_file_relative = format_info.in_file, format_info.in_file_relative - contract_name = format_info.contract_name + name = get_name(element) + contract_name = get_contract_name(element) # Get only event name without parameters event_name = name.split('(')[0] @@ -405,9 +541,7 @@ def _create_patch_event_calls(format_info): int(call.source_mapping['start']) + int(call.source_mapping['length'])] - create_patch(patches, - "naming-convention (event calls)", - in_file_relative, + create_patch(result, in_file, call.source_mapping['start'], int(call.source_mapping['start']) + int(call.source_mapping['length']), @@ -416,277 +550,233 @@ def _create_patch_event_calls(format_info): old_str_of_interest.decode('utf-8').capitalize()) -def _create_patch_parameter_declaration(format_info): - slither, patches, name = format_info.slither, format_info.patches, format_info.name - in_file, in_file_relative = format_info.in_file, format_info.in_file_relative - contract_name = format_info.contract_name - modify_loc_start, modify_loc_end = format_info.loc_start, format_info.loc_end - function_name = format_info.function_name +def _create_patch_parameter_uses(slither, result, element): - target_contract = slither.get_contract_from_name(contract_name) - if not target_contract: - raise SlitherException("Contract not found?!") - for function in target_contract.functions: - if function.name == function_name: - in_file_str = slither.source_code[in_file].encode('utf-8') - old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - # To-do: Change format logic below - how do we convert a name to mixedCase? - if(name[0] == '_'): - # If parameter name begins with underscore, capitalize the letter after underscore - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+name[0]+name[1].upper() + - name[2:]+r'\2', old_str_of_interest.decode('utf-8'), 1) - else: - # Add underscore and capitalize the first letter - (new_str_of_interest, num_repl) = re.subn(r'(.*)' + name + r'(.*)', r'\1' + '_' + name.capitalize() + - r'\2', old_str_of_interest.decode('utf-8'), 1) - if num_repl != 0: - create_patch(patches, - "naming-convention (parameter declaration)", - in_file_relative, - in_file, - modify_loc_start, - modify_loc_end, - old_str_of_interest.decode('utf-8'), - new_str_of_interest) - else: - raise SlitherException("Could not find parameter declaration?!") + in_file, in_file_str, old_str_of_interest, loc_start, loc_end = _unpack_info(slither, element) + name = get_name(element) + contract_name = get_contract_name(element) -def _create_patch_parameter_uses(format_info): - slither, patches, name = format_info.slither, format_info.patches, format_info.name - in_file, in_file_relative = format_info.in_file, format_info.in_file_relative - contract_name = format_info.contract_name - function_name = format_info.function_name + function_sig = element['type_specific_fields']['parent']['type_specific_fields']['signature'] target_contract = slither.get_contract_from_name(contract_name) - for function in target_contract.functions: - if (function.name == function_name): - in_file_str = slither.source_code[in_file].encode('utf-8') - for node in function.nodes: - vars = node._expression_vars_written + node._expression_vars_read - for v in vars: - if isinstance(v, Identifier) and str(v) == name and [str(lv) for lv in - (node._local_vars_read + - node._local_vars_written) - if str(lv) == name]: - # Skip rare cases where source_mapping is absent. To-do: Investigate - if not v.source_mapping: - continue - modify_loc_start = int(v.source_mapping['start']) - modify_loc_end = int(v.source_mapping['start']) + int(v.source_mapping['length']) - old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - # To-do: Change format logic below - how do we convert a name to mixedCase? - if(name[0] == '_'): - # If parameter name begins with underscore, capitalize the letter after underscore - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', - r'\1'+name[0]+name[1].upper()+name[2:] + - r'\2', old_str_of_interest.decode('utf-8'), - 1) - else: - # Add underscore and capitalize the first letter - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+'_' + - name.capitalize()+r'\2', - old_str_of_interest.decode('utf-8'), 1) - if num_repl != 0: - create_patch(patches, - "naming-convention (parameter uses)", - in_file_relative, - in_file, - modify_loc_start, - modify_loc_end, - old_str_of_interest.decode('utf-8'), - new_str_of_interest) - else: - raise SlitherException("Could not find parameter use?!") - - # Process function parameters passed to modifiers - for modifier in function._expression_modifiers: - for arg in modifier.arguments: - if str(arg) == name: - old_str_of_interest = in_file_str[modifier.source_mapping['start']: - modifier.source_mapping['start'] + - modifier.source_mapping['length']] - # Get text beyond modifier name which contains parameters - old_str_of_interest_beyond_modifier_name = old_str_of_interest.decode('utf-8')\ - .split('(')[1] - # To-do: Change format logic below - how do we convert a name to mixedCase? - if(name[0] == '_'): - # If parameter name begins with underscore, capitalize the letter after underscore - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+name[0]+ - name[1].upper()+name[2:]+r'\2', - old_str_of_interest_beyond_modifier_name, 1) - else: - # Add underscore and capitalize the first letter - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+'_'+ - name.capitalize()+r'\2', - old_str_of_interest_beyond_modifier_name, 1) - if num_repl != 0: - create_patch(patches, - "naming-convention (parameter uses)", - in_file_relative, - in_file, - # Start beyond modifier name which contains parameters - modifier.source_mapping['start'] + - len(old_str_of_interest.decode('utf-8').split('(')[0]) + 1, - modifier.source_mapping['start'] + modifier.source_mapping['length'], - old_str_of_interest_beyond_modifier_name, - new_str_of_interest) - else: - raise SlitherException("Could not find parameter use in modifier?!") + function = target_contract.get_function_from_signature(function_sig) + + for node in function.nodes: + # _expression_* are used to access the source mapping of the call rather + # than the body definition + vars = node._expression_vars_written + node._expression_vars_read + for v in vars: + if isinstance(v, Identifier) and str(v) == name and [str(lv) for lv in + (node._local_vars_read + + node._local_vars_written) + if str(lv) == name]: + # Skip rare cases where source_mapping is absent. To-do: Investigate + if not v.source_mapping: + continue + modify_loc_start = int(v.source_mapping['start']) + modify_loc_end = int(v.source_mapping['start']) + int(v.source_mapping['length']) + old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + # To-do: Change format logic below - how do we convert a name to mixedCase? + if(name[0] == '_'): + # If parameter name begins with underscore, capitalize the letter after underscore + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', + r'\1'+name[0]+name[1].upper()+name[2:] + + r'\2', old_str_of_interest.decode('utf-8'), + 1) + else: + # Add underscore and capitalize the first letter + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+'_' + + name.capitalize()+r'\2', + old_str_of_interest.decode('utf-8'), 1) + if num_repl != 0: + create_patch(result, + in_file, + modify_loc_start, + modify_loc_end, + old_str_of_interest.decode('utf-8'), + new_str_of_interest) + else: + raise SlitherException("Could not find parameter use?!") + + # Process function parameters passed to modifiers + # _expression_modifiers is used to access the source mapping of the call rather + # than the body definition + for modifier in function._expression_modifiers: + for arg in modifier.arguments: + if str(arg) == name: + old_str_of_interest = in_file_str[modifier.source_mapping['start']: + modifier.source_mapping['start'] + + modifier.source_mapping['length']] + # Get text beyond modifier name which contains parameters + old_str_of_interest_beyond_modifier_name = old_str_of_interest.decode('utf-8')\ + .split('(')[1] + # To-do: Change format logic below - how do we convert a name to mixedCase? + if(name[0] == '_'): + # If parameter name begins with underscore, capitalize the letter after underscore + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+name[0]+ + name[1].upper()+name[2:]+r'\2', + old_str_of_interest_beyond_modifier_name, 1) + else: + # Add underscore and capitalize the first letter + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+'_'+ + name.capitalize()+r'\2', + old_str_of_interest_beyond_modifier_name, 1) + if num_repl != 0: + create_patch(result, + in_file, + # Start beyond modifier name which contains parameters + modifier.source_mapping['start'] + + len(old_str_of_interest.decode('utf-8').split('(')[0]) + 1, + modifier.source_mapping['start'] + modifier.source_mapping['length'], + old_str_of_interest_beyond_modifier_name, + new_str_of_interest) + else: + raise SlitherException("Could not find parameter use in modifier?!") + +def _create_patch_state_variable_uses(slither, result, element): + in_file, in_file_str, old_str_of_interest, loc_start, loc_end = _unpack_info(slither, element) -def _create_patch_state_variable_uses(format_info): - slither, patches, name = format_info.slither, format_info.patches, format_info.name - in_file, in_file_relative = format_info.in_file, format_info.in_file_relative - contract_name = format_info.contract_name - _target = format_info.target + name = get_name(element) + contract_name = get_contract_name(element) # To-do: Check cross-contract state variable uses target_contract = slither.get_contract_from_name(contract_name) if not target_contract: raise SlitherException(f"Contract not found {contract_name}") - for contract in [target_contract] + target_contract.derived_contracts: - fms = contract.functions + contract.modifiers - for fm in fms: - for node in fm.nodes: - vars = node._expression_vars_written + node._expression_vars_read - for v in vars: - if isinstance(v, Identifier) and str(v) == name and [str(sv) for sv in - (node._state_vars_read + - node._state_vars_written) - if str(sv) == name]: - modify_loc_start = int(v.source_mapping['start']) - modify_loc_end = int(v.source_mapping['start']) + int(v.source_mapping['length']) - in_file_str = slither.source_code[in_file].encode('utf-8') - old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - if (_target == "variable_constant"): - # Convert constant state variables to upper case - new_str_of_interest = old_str_of_interest.decode('utf-8').upper() - else: - new_str_of_interest = old_str_of_interest.decode('utf-8') - new_str_of_interest = new_str_of_interest[0].lower()+new_str_of_interest[1:] - - create_patch(patches, - "naming-convention (state variable uses)", - in_file_relative, - in_file, - modify_loc_start, - modify_loc_end, - old_str_of_interest.decode('utf-8'), - new_str_of_interest) + fms = target_contract.functions + target_contract.modifiers + for fm in fms: + for node in fm.nodes: + vars = node._expression_vars_written + node._expression_vars_read + for v in vars: + if isinstance(v, Identifier) and str(v) == name and [str(sv) for sv in + (node._state_vars_read + + node._state_vars_written) + if str(sv) == name]: + modify_loc_start = int(v.source_mapping['start']) + modify_loc_end = int(v.source_mapping['start']) + int(v.source_mapping['length']) + in_file_str = slither.source_code[in_file].encode('utf-8') + old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] + if (element['additional_fields']['target'] == "variable_constant"): + # Convert constant state variables to upper case + new_str_of_interest = old_str_of_interest.decode('utf-8').upper() + else: + new_str_of_interest = old_str_of_interest.decode('utf-8') + new_str_of_interest = new_str_of_interest[0].lower()+new_str_of_interest[1:] + create_patch(result, + in_file, + modify_loc_start, + modify_loc_end, + old_str_of_interest.decode('utf-8'), + new_str_of_interest) +def _create_patch_enum_uses(slither, result, element): + in_file, in_file_str, old_str_of_interest, loc_start, loc_end = _unpack_info(slither, element) -def _create_patch_enum_uses(format_info): - slither, patches, name = format_info.slither, format_info.patches, format_info.name - in_file, in_file_relative = format_info.in_file, format_info.in_file_relative - contract_name = format_info.contract_name + name = get_name(element) + contract_name = get_contract_name(element) target_contract = slither.get_contract_from_name(contract_name) if not target_contract: raise SlitherException(f"Contract not found {contract_name}") - for contract in [target_contract] + target_contract.derived_contracts: - in_file_str = slither.source_code[in_file].encode('utf-8') - # Check state variable declarations of enum type - # To-do: Deep-check aggregate types (struct and mapping) - svs = contract.variables - for sv in svs: - if (str(sv.type) == contract_name + "." + name): - old_str_of_interest = in_file_str[sv.source_mapping['start']:(sv.source_mapping['start']+ - sv.source_mapping['length'])] + in_file_str = slither.source_code[in_file].encode('utf-8') + # Check state variable declarations of enum type + # To-do: Deep-check aggregate types (struct and mapping) + svs = target_contract.variables + for sv in svs: + if (str(sv.type) == contract_name + "." + name): + old_str_of_interest = in_file_str[sv.source_mapping['start']:(sv.source_mapping['start']+ + sv.source_mapping['length'])] + (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(), + old_str_of_interest.decode('utf-8'), 1) + + create_patch(result, + in_file, + sv.source_mapping['start'], + sv.source_mapping['start'] + sv.source_mapping['length'], + old_str_of_interest.decode('utf-8'), + new_str_of_interest) + + # Check function+modifier locals+parameters+returns + # To-do: Deep-check aggregate types (struct and mapping) + fms = target_contract.functions + target_contract.modifiers + for fm in fms: + # Enum declarations + for v in fm.variables: + if (str(v.type) == contract_name + "." + name): + old_str_of_interest = in_file_str[v.source_mapping['start']:(v.source_mapping['start']+ + v.source_mapping['length'])] (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(), old_str_of_interest.decode('utf-8'), 1) - create_patch(patches, - "naming-convention (enum use)", - in_file_relative, + create_patch(result, in_file, - sv.source_mapping['start'], - sv.source_mapping['start'] + sv.source_mapping['length'], + v.source_mapping['start'], + v.source_mapping['start'] + v.source_mapping['length'], old_str_of_interest.decode('utf-8'), new_str_of_interest) - # Check function+modifier locals+parameters+returns - # To-do: Deep-check aggregate types (struct and mapping) - fms = contract.functions + contract.modifiers - for fm in fms: - # Enum declarations - for v in fm.variables: - if (str(v.type) == contract_name + "." + name): - old_str_of_interest = in_file_str[v.source_mapping['start']:(v.source_mapping['start']+ - v.source_mapping['length'])] - (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(), - old_str_of_interest.decode('utf-8'), 1) - - create_patch(patches, - "naming-convention (enum use)", - in_file_relative, - in_file, - v.source_mapping['start'], - v.source_mapping['start'] + v.source_mapping['length'], - old_str_of_interest.decode('utf-8'), - new_str_of_interest) + # Capture enum uses such as "num = numbers.ONE;" + for function in target_contract.functions: + for node in function.nodes: + for ir in node.irs: + if isinstance(ir, Member): + if str(ir.variable_left) == name: + # Skip past the assignment + old_str_of_interest = in_file_str[node.source_mapping['start']: + (node.source_mapping['start']+ + node.source_mapping['length'])].decode('utf-8')\ + .split('=')[1] + m = re.search(r'(.*)'+name, old_str_of_interest) + # Skip rare cases where re search fails. To-do: Investigate + if not m: + continue + old_str_of_interest = old_str_of_interest[m.span()[0]:] + (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name, r'\1'+name.capitalize(), + old_str_of_interest, 1) + if num_repl != 0: - # Capture enum uses such as "num = numbers.ONE;" - for function in contract.functions: - for node in function.nodes: - for ir in node.irs: - if isinstance(ir, Member): - if str(ir.variable_left) == name: - # Skip past the assignment - old_str_of_interest = in_file_str[node.source_mapping['start']: - (node.source_mapping['start']+ - node.source_mapping['length'])].decode('utf-8')\ - .split('=')[1] - m = re.search(r'(.*)'+name, old_str_of_interest) - # Skip rare cases where re search fails. To-do: Investigate - if not m: - continue - old_str_of_interest = old_str_of_interest[m.span()[0]:] - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name, r'\1'+name.capitalize(), - old_str_of_interest, 1) - if num_repl != 0: - - # TODO (JF): review me - # Start past the assignment - loc_start = node.source_mapping['start'] + \ - len(in_file_str[node.source_mapping['start']: - (node.source_mapping['start']+ - node.source_mapping['length'])].decode('utf-8').split('=')[0]) + \ - 1 + m.span()[0] - - # End accounts for the assignment from the start - loc_end = node.source_mapping['start'] +\ - len(in_file_str[node.source_mapping['start']:(node.source_mapping['start']+ - node.source_mapping['length'])].\ - decode('utf-8').split('=')[0]) + 1 + m.span()[0] + len(old_str_of_interest) - - create_patch(patches, - "naming-convention (enum use)", - in_file_relative, - in_file, - loc_start, - loc_end, - old_str_of_interest, - new_str_of_interest) + # TODO (JF): review me + # Start past the assignment + loc_start = node.source_mapping['start'] + \ + len(in_file_str[node.source_mapping['start']: + (node.source_mapping['start']+ + node.source_mapping['length'])].decode('utf-8').split('=')[0]) + \ + 1 + m.span()[0] + + # End accounts for the assignment from the start + loc_end = node.source_mapping['start'] +\ + len(in_file_str[node.source_mapping['start']:(node.source_mapping['start']+ + node.source_mapping['length'])].\ + decode('utf-8').split('=')[0]) + 1 + m.span()[0] + len(old_str_of_interest) + + create_patch(result, + in_file, + loc_start, + loc_end, + old_str_of_interest, + new_str_of_interest) - else: - raise SlitherException("Could not find new object?!") + else: + raise SlitherException("Could not find new object?!") # To-do: Check any other place/way where enum type is used -def _create_patch_struct_uses(format_info): - slither, patches, name = format_info.slither, format_info.patches, format_info.name - in_file, in_file_relative = format_info.in_file, format_info.in_file_relative - contract_name = format_info.contract_name +def _create_patch_struct_uses(slither, result, element): + in_file, in_file_str, old_str_of_interest, loc_start, loc_end = _unpack_info(slither, element) + + name = get_name(element) + contract_name = get_contract_name(element) target_contract = slither.get_contract_from_name(contract_name) if not target_contract: @@ -704,9 +794,7 @@ def _create_patch_struct_uses(format_info): (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(), old_str_of_interest.decode('utf-8'), 1) - create_patch(patches, - "naming-convention (struct use)", - in_file_relative, + create_patch(result, in_file, sv.source_mapping['start'], sv.source_mapping['start'] + sv.source_mapping['length'], @@ -723,9 +811,7 @@ def _create_patch_struct_uses(format_info): (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(), old_str_of_interest.decode('utf-8'), 1) - create_patch(patches, - "naming-convention (struct use)", - in_file_relative, + create_patch(result, in_file, v.source_mapping['start'], v.source_mapping['start'] + v.source_mapping['length'], @@ -735,151 +821,4 @@ def _create_patch_struct_uses(format_info): - - # endregion -################################################################################### -################################################################################### -# region Declaration -################################################################################### -################################################################################### - - -def _create_patch_declaration(format_info, convert_string): - slither, patches, name = format_info.slither, format_info.patches, format_info.name - in_file, in_file_relative = format_info.in_file, format_info.in_file_relative - modify_loc_start, modify_loc_end = format_info.loc_start, format_info.loc_end - - in_file_str = slither.source_code[in_file].encode('utf-8') - - - convert_res = convert_string(name, - in_file_str, - modify_loc_start, - modify_loc_end) - - if convert_res: - old_string, new_string, loc_start, loc_end, detector_name = convert_res - - create_patch(patches, - detector_name, - in_file_relative, - in_file, - loc_start, - loc_end, - old_string, - new_string) - -def _convert_contract_declaration(name, in_file_str, loc_start, loc_end): - old_str_of_interest = in_file_str[loc_start:loc_end] - # Locate the name following keywords `contract` | `interface` | `library` - m = re.match(r'(.*)' + "(contract|interface|library)" + r'(.*)' + name, old_str_of_interest.decode('utf-8')) - old_str_of_interest = in_file_str[loc_start:loc_start+m.span()[1]] - # Capitalize the name - (new_string, num_repl) = re.subn(r'(.*)' + r'(contract|interface|library)' + r'(.*)' + name, - r'\1' + r'\2' + r'\3' + name.capitalize(), - old_str_of_interest.decode('utf-8'), 1) - - if num_repl == 0: - raise SlitherException(f"Could not find contract: {name}") - - old_string = old_str_of_interest.decode('utf-8') - - loc_start = loc_start - loc_end = loc_start + m.span()[1] - - detector_name = "naming-convention (contract declaration)" - - return old_string, new_string, loc_start, loc_end, detector_name - - -def _convert_state_variable_declaration(name, in_file_str, loc_start, loc_end): - old_str_of_interest = in_file_str[loc_start:loc_end] - m = re.search(name, old_str_of_interest.decode('utf-8')) - # Skip rare cases where re search fails. To-do: Investigate - if not m: - return None - new_string = old_str_of_interest.decode('utf-8')[m.span()[0]:m.span()[1]] - new_string = new_string[0].lower() + new_string[1:] - - old_string = old_str_of_interest.decode('utf-8')[m.span()[0]:m.span()[1]] - - loc_start = loc_start + m.span()[0] - loc_end = loc_start + m.span()[1] - - detector_name = "naming-convention (state variable declaration)" - - return old_string, new_string, loc_start, loc_end, detector_name - - -def _convert_state_variable_constant_declaration(name, in_file_str, loc_start, loc_end): - old_str_of_interest = in_file_str[loc_start:loc_end] - m = re.search(name, old_str_of_interest.decode('utf-8')) - # Skip rare cases where re search fails. To-do: Investigate - if not m: - return None - # Convert constant state variables to upper case - new_string = old_str_of_interest.decode('utf-8')[m.span()[0]:m.span()[1]].upper() - - old_string = old_str_of_interest.decode('utf-8')[m.span()[0]:m.span()[1]] - - loc_start = loc_start + m.span()[0] - loc_end = loc_start + m.span()[1] - - detector_name = "naming-convention (state variable declaration)" - - return old_string, new_string, loc_start, loc_end, detector_name - - -def _convert_enum_declaration(name, in_file_str, loc_start, loc_end): - old_str_of_interest = in_file_str[loc_start:loc_end] - m = re.search(name, old_str_of_interest.decode('utf-8')) - # Skip rare cases where re search fails. To-do: Investigate - if not m: - return None - # Search for the enum name after the `enum` keyword - # Capitalize enum name - (new_string, num_repl) = re.subn(r'(.*)' + "enum" + r'(.*)' + name, r'\1' + "enum" + r'\2' + - name[0].capitalize() + name[1:], - old_str_of_interest.decode('utf-8'), 1) - - if num_repl == 0: - raise SlitherException(f"Could not find enum: {name}") - - old_string = old_str_of_interest.decode('utf-8') - - loc_start = loc_start - loc_end = loc_end - - detector_name = "naming-convention (enum declaration)" - - return old_string, new_string, loc_start, loc_end, detector_name - - -def _convert_struct_definition(name, in_file_str, loc_start, loc_end): - old_str_of_interest = in_file_str[loc_start:loc_end] - m = re.search(name, old_str_of_interest.decode('utf-8')) - # Skip rare cases where re search fails. To-do: Investigate - if not m: - return None - # Capitalize the struct name beyond the keyword `struct` - - (new_string, num_repl) = re.subn(r'(.*)'+"struct"+r'(.*)'+name, r'\1'+"struct"+r'\2'+ - name.capitalize(), - old_str_of_interest.decode('utf-8'), 1) - - if num_repl == 0: - raise SlitherException(f"Could not find struct: {name}") - - old_string = old_str_of_interest.decode('utf-8') - - loc_start = loc_start - loc_end = loc_end - - detector_name = "naming-convention (struct definition)" - - return old_string, new_string, loc_start, loc_end, detector_name - - - -# endregion \ No newline at end of file diff --git a/utils/slither_format/formatters/pragma.py b/utils/slither_format/formatters/pragma.py index ebb0689f4..737aa8fe7 100644 --- a/utils/slither_format/formatters/pragma.py +++ b/utils/slither_format/formatters/pragma.py @@ -14,14 +14,14 @@ REPLACEMENT_VERSIONS = ["0.4.25", "0.5.3"] PATTERN = re.compile('(\^|>|>=|<|<=)?([ ]+)?(\d+)\.(\d+)\.(\d+)') -def format(slither, patches, elements): +def format(slither, result): + elements = result['elements'] versions_used = [] for element in elements: versions_used.append(''.join(element['type_specific_fields']['directive'][1:])) solc_version_replace = _analyse_versions(versions_used) for element in elements: - _patch(slither, patches, element['source_mapping']['filename_absolute'], - element['source_mapping']['filename_relative'], solc_version_replace, + _patch(slither, result, element['source_mapping']['filename_absolute'], solc_version_replace, element['source_mapping']['start'], element['source_mapping']['start'] + element['source_mapping']['length']) @@ -58,12 +58,10 @@ def _determine_solc_version_replacement(used_solc_version): return "pragma solidity " + REPLACEMENT_VERSIONS[1] + ';' -def _patch(slither, patches, in_file, in_file_relative, pragma, modify_loc_start, modify_loc_end): +def _patch(slither, result, in_file, pragma, modify_loc_start, modify_loc_end): in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - create_patch(patches, - "pragma", - in_file_relative, + create_patch(result, in_file, int(modify_loc_start), int(modify_loc_end), diff --git a/utils/slither_format/formatters/solc_version.py b/utils/slither_format/formatters/solc_version.py index f03a96702..ead6cad97 100644 --- a/utils/slither_format/formatters/solc_version.py +++ b/utils/slither_format/formatters/solc_version.py @@ -14,12 +14,13 @@ REPLACEMENT_VERSIONS = ["0.4.25", "0.5.3"] # 4: version number PATTERN = re.compile('(\^|>|>=|<|<=)?([ ]+)?(\d+)\.(\d+)\.(\d+)') -def format(slither, patches, elements): +def format(slither, result): + elements = result['elements'] for element in elements: solc_version_replace = _determine_solc_version_replacement( ''.join(element['type_specific_fields']['directive'][1:])) - _patch(slither, patches, element['source_mapping']['filename_absolute'], - element['source_mapping']['filename_relative'], solc_version_replace, + + _patch(slither, result, element['source_mapping']['filename_absolute'], solc_version_replace, element['source_mapping']['start'], element['source_mapping']['start'] + element['source_mapping']['length']) @@ -47,12 +48,10 @@ def _determine_solc_version_replacement(used_solc_version): return "pragma solidity " + REPLACEMENT_VERSIONS[1] + ';' -def _patch(slither, patches, in_file, in_file_relative, solc_version, modify_loc_start, modify_loc_end): +def _patch(slither, result, in_file, solc_version, modify_loc_start, modify_loc_end): in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - create_patch(patches, - "solc-version", - in_file_relative, + create_patch(result, in_file, int(modify_loc_start), int(modify_loc_end), diff --git a/utils/slither_format/formatters/unused_state.py b/utils/slither_format/formatters/unused_state.py index c64f33190..dcc5e830c 100644 --- a/utils/slither_format/formatters/unused_state.py +++ b/utils/slither_format/formatters/unused_state.py @@ -1,22 +1,24 @@ from ..utils.patches import create_patch -def format(slither, patches, elements): +def format(slither, result): + elements = result['elements'] for element in elements: if element['type'] == "variable": - _patch(slither, patches, + _patch(slither, + result, element['source_mapping']['filename_absolute'], element['source_mapping']['filename_relative'], element['source_mapping']['start']) -def _patch(slither, patches, in_file, in_file_relative, modify_loc_start): +def _patch(slither, result, in_file, in_file_relative, modify_loc_start): in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:] old_str = old_str_of_interest.decode('utf-8').partition(';')[0]\ + old_str_of_interest.decode('utf-8').partition(';')[1] - create_patch(patches, + create_patch(result, "unused-state", in_file_relative, in_file, diff --git a/utils/slither_format/slither_format.py b/utils/slither_format/slither_format.py index bcfba7dbe..0ec391ed2 100644 --- a/utils/slither_format/slither_format.py +++ b/utils/slither_format/slither_format.py @@ -1,5 +1,6 @@ -import sys, logging, subprocess -from collections import defaultdict +import sys +import logging +import os 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 @@ -25,9 +26,13 @@ all_detectors = { 'constant-function': ConstantFunctions } -def slither_format(args, slither): - patches = defaultdict(list) - detectors_to_run = choose_detectors(args) +def slither_format(slither, **kwargs): + '''' + Keyword Args: + detectors_to_run (str): Comma-separated list of detectors, defaults to all + ''' + + detectors_to_run = choose_detectors(kwargs.get('detectors_to_run', 'all')) for detector in detectors_to_run: slither.register_detector(detector) @@ -36,36 +41,88 @@ def slither_format(args, slither): 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 - # Apply slither detector results on contract files to generate patches - apply_detector_results(slither, patches, detector_results) + apply_detector_results(slither, detector_results) + + skip_file_generation = kwargs.get('skip-patch-generation', False) counter = 0 - for file in patches: - for patch in patches[file]: - print(file) - print(patch['file']) - original_txt = slither.source_code[patch['file']] - patched_txt = apply_patch(original_txt, patch) + export = os.path.join('crytic-export', 'patches') + + if not os.path.exists(export): + os.makedirs(export) + + for result in detector_results: + if not 'patches' in result: + continue + one_line_description = result["description"].split("\n")[0] + logger.info(f'Issue: {one_line_description}') + logger.info('Generated:') + for file in result['patches']: + original_txt = slither.source_code[file] + patched_txt = original_txt + for patch in result['patches'][file]: + patched_txt = apply_patch(patched_txt, patch) diff = create_diff(original_txt, patched_txt, file) - with open(f'patch_{counter}', 'w') as f: + if not skip_file_generation: + continue + path = os.path.join(export, f'fix_{counter}.patch') + logger.info(f'\t- {path}') + with open(path, 'w') as f: f.write(diff) + counter = counter + 1 + +# endregion +################################################################################### +################################################################################### +# region Detectors +################################################################################### +################################################################################### +def choose_detectors(detectors_to_run): + # If detectors are specified, run only these ones + cls_detectors_to_run = [] + if detectors_to_run == 'all': + for d in all_detectors: + cls_detectors_to_run.append(all_detectors[d]) + else: + for d in detectors_to_run.split(','): + if d in all_detectors: + cls_detectors_to_run.append(all_detectors[d]) + else: + raise Exception('Error: {} is not a detector'.format(d)) + return cls_detectors_to_run + +def apply_detector_results(slither, detector_results): + ''' + Apply slither detector results on contract files to generate patches + ''' + for result in detector_results: + if result['check'] == 'unused-state': + unused_state.format(slither, result) + elif result['check'] == 'solc-version': + solc_version.format(slither, result) + elif result['check'] == 'pragma': + pragma.format(slither, result) + elif result['check'] == 'naming-convention': + naming_convention.format(slither, result) + elif result['check'] == 'external-function': + external_function.format(slither, result) + elif result['check'] == 'constable-states': + constable_states.format(slither, result) + elif result['check'] == 'constant-function': + constable_states.format(slither, result) + else: + logger.error(red(result['check'] + "detector not supported yet.")) + sys.exit(-1) - # # Sort the patches in ascending order of the source mapping i.e. from beginning of contract file to end. - # # Multiple detectors can produce alerts on same code fragments e.g. unused-state and constable-states. - # # The current approach makes a single pass on the contract file to apply patches. - # # Therefore, overlapping patches are ignored for now. Neither is applied. - # # To-do: Prioritise one detector over another (via user input or hardcoded) for overlapping patches. - # sort_and_flag_overlapping_patches(patches) - # # Remove overlapping 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 git-compatible patch files - # generate_patch_files(slither, patches) + +# endregion +################################################################################### +################################################################################### +# region Patch triage (disable) +################################################################################### +################################################################################### def sort_and_flag_overlapping_patches(patches): for file in patches: @@ -105,34 +162,14 @@ 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') - - out_file = open(_in_file+".format",'w') - out_file.write(out_file_str) - out_file.close() - logger.info("slither-format successful.") - logger.info(f"Created formatted file: {_in_file}.format") - patch_file_name = _in_file + ".format.patch" - outFD = open(patch_file_name,"w") - logger.info(f'Created patch: {patch_file_name}') - p1 = subprocess.Popen(['diff', '-u', _in_file, _in_file+".format"], stdout=outFD) - p1.wait() - outFD.close() + + +# endregion +################################################################################### +################################################################################### +# region Debug functions +################################################################################### +################################################################################### def print_patches(number_of_slither_results, patches): logger.info("Number of Slither results: " + str(number_of_slither_results)) @@ -179,51 +216,3 @@ def print_patches_json(number_of_slither_results, patches): 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): - ''' - Apply slither detector results on contract files to generate patches - ''' - for result in detector_results: - if result['check'] == 'unused-state': - unused_state.format(slither, patches, result['elements']) - elif result['check'] == 'solc-version': - solc_version.format(slither, patches, result['elements']) - elif result['check'] == 'pragma': - pragma.format(slither, patches, result['elements']) - elif result['check'] == 'naming-convention': - naming_convention.format(slither, patches, result['elements']) - elif result['check'] == 'external-function': - external_function.format(slither, patches, result['elements']) - elif result['check'] == 'constable-states': - constable_states.format(slither, patches, result['elements']) - elif result['check'] == 'constant-function': - constable_states.format(slither, patches, result['elements']) - else: - logger.error(red(result['check'] + "detector 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 - diff --git a/utils/slither_format/utils/patches.py b/utils/slither_format/utils/patches.py index 6a8898f0f..66539a40a 100644 --- a/utils/slither_format/utils/patches.py +++ b/utils/slither_format/utils/patches.py @@ -1,25 +1,25 @@ import difflib +from collections import defaultdict -def create_patch(patches, detector, file_relative, file, start, end, old_str, new_str): - p = { - "file": file, - "detector": detector, - "start": start, - "end": end, - "old_string": old_str, - "new_string": new_str +def create_patch(result, file, start, end, old_str, new_str): + p = {"start": start, + "end": end, + "old_string": old_str, + "new_string": new_str } - if p not in patches[file_relative]: - patches[file_relative].append(p) + if 'patches' not in result: + result['patches'] = defaultdict(list) + if p not in result['patches'][file]: + result['patches'][file].append(p) def apply_patch(original_txt, patch): patched_txt = original_txt[:int(patch['start'])] patched_txt += patch['new_string'] patched_txt += original_txt[int(patch['end']):] - print(patched_txt) return patched_txt + def create_diff(original_txt, patched_txt, filename): diff = difflib.unified_diff(original_txt.splitlines(False), patched_txt.splitlines(False), From 3491de659e0e19e463bb84e6c2977f390c5d93e3 Mon Sep 17 00:00:00 2001 From: Josselin Date: Thu, 27 Jun 2019 11:22:51 +0200 Subject: [PATCH 071/223] Add missing __init__.py files --- utils/slither_format/formatters/__init__.py | 0 utils/slither_format/utils/__init__.py | 0 2 files changed, 0 insertions(+), 0 deletions(-) create mode 100644 utils/slither_format/formatters/__init__.py create mode 100644 utils/slither_format/utils/__init__.py diff --git a/utils/slither_format/formatters/__init__.py b/utils/slither_format/formatters/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/utils/slither_format/utils/__init__.py b/utils/slither_format/utils/__init__.py new file mode 100644 index 000000000..e69de29bb From a0e220b64489fad7a36868be0810ccf2f15eec35 Mon Sep 17 00:00:00 2001 From: Josselin Date: Thu, 27 Jun 2019 11:38:28 +0200 Subject: [PATCH 072/223] Fix minor bugs, improve patch generation --- utils/slither_format/formatters/constant_function.py | 2 -- utils/slither_format/formatters/unused_state.py | 5 +---- utils/slither_format/slither_format.py | 4 ++-- utils/slither_format/utils/patches.py | 10 +++++++--- 4 files changed, 10 insertions(+), 11 deletions(-) diff --git a/utils/slither_format/formatters/constant_function.py b/utils/slither_format/formatters/constant_function.py index 00cf42dcb..22c538baf 100644 --- a/utils/slither_format/formatters/constant_function.py +++ b/utils/slither_format/formatters/constant_function.py @@ -26,8 +26,6 @@ def _patch(slither, patches, in_file, in_file_relative, modify_loc_start, modify m = re.search("(view|pure|constant)", old_str_of_interest.decode('utf-8')) if m: create_patch(patches, - "constant-function", - in_file_relative, in_file, modify_loc_start + m.span()[0], modify_loc_start + m.span()[1], diff --git a/utils/slither_format/formatters/unused_state.py b/utils/slither_format/formatters/unused_state.py index dcc5e830c..2bb3abee1 100644 --- a/utils/slither_format/formatters/unused_state.py +++ b/utils/slither_format/formatters/unused_state.py @@ -8,19 +8,16 @@ def format(slither, result): _patch(slither, result, element['source_mapping']['filename_absolute'], - element['source_mapping']['filename_relative'], element['source_mapping']['start']) -def _patch(slither, result, in_file, in_file_relative, modify_loc_start): +def _patch(slither, result, in_file, modify_loc_start): in_file_str = slither.source_code[in_file].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:] old_str = old_str_of_interest.decode('utf-8').partition(';')[0]\ + old_str_of_interest.decode('utf-8').partition(';')[1] create_patch(result, - "unused-state", - in_file_relative, in_file, int(modify_loc_start), # Remove the entire declaration until the semicolon diff --git a/utils/slither_format/slither_format.py b/utils/slither_format/slither_format.py index 0ec391ed2..7b2bf12cc 100644 --- a/utils/slither_format/slither_format.py +++ b/utils/slither_format/slither_format.py @@ -62,8 +62,8 @@ def slither_format(slither, **kwargs): patched_txt = original_txt for patch in result['patches'][file]: patched_txt = apply_patch(patched_txt, patch) - diff = create_diff(original_txt, patched_txt, file) - if not skip_file_generation: + diff = create_diff(slither, original_txt, patched_txt, file) + if skip_file_generation: continue path = os.path.join(export, f'fix_{counter}.patch') logger.info(f'\t- {path}') diff --git a/utils/slither_format/utils/patches.py b/utils/slither_format/utils/patches.py index 66539a40a..25e9bed6b 100644 --- a/utils/slither_format/utils/patches.py +++ b/utils/slither_format/utils/patches.py @@ -20,11 +20,15 @@ def apply_patch(original_txt, patch): return patched_txt -def create_diff(original_txt, patched_txt, filename): +def create_diff(slither, original_txt, patched_txt, filename): + if slither.crytic_compile: + relative_path = slither.crytic_compile.filename_lookup(filename).relative + else: + relative_path = filename diff = difflib.unified_diff(original_txt.splitlines(False), patched_txt.splitlines(False), - fromfile=filename, - tofile=filename, + fromfile=relative_path, + tofile=relative_path, lineterm='') return '\n'.join(list(diff)) + '\n' From b94f5e21c0318c29cbded1224acd660f4003470e Mon Sep 17 00:00:00 2001 From: Josselin Date: Thu, 27 Jun 2019 11:48:06 +0200 Subject: [PATCH 073/223] Improve patch generation --- utils/slither_format/slither_format.py | 1 + utils/slither_format/utils/patches.py | 2 ++ 2 files changed, 3 insertions(+) diff --git a/utils/slither_format/slither_format.py b/utils/slither_format/slither_format.py index 7b2bf12cc..c94712255 100644 --- a/utils/slither_format/slither_format.py +++ b/utils/slither_format/slither_format.py @@ -63,6 +63,7 @@ def slither_format(slither, **kwargs): for patch in result['patches'][file]: patched_txt = apply_patch(patched_txt, patch) diff = create_diff(slither, original_txt, patched_txt, file) + result['paches_diff'] = diff if skip_file_generation: continue path = os.path.join(export, f'fix_{counter}.patch') diff --git a/utils/slither_format/utils/patches.py b/utils/slither_format/utils/patches.py index 25e9bed6b..cf4bacb72 100644 --- a/utils/slither_format/utils/patches.py +++ b/utils/slither_format/utils/patches.py @@ -1,3 +1,4 @@ +import os import difflib from collections import defaultdict @@ -23,6 +24,7 @@ def apply_patch(original_txt, patch): def create_diff(slither, original_txt, patched_txt, filename): if slither.crytic_compile: relative_path = slither.crytic_compile.filename_lookup(filename).relative + relative_path = os.path.join('.', relative_path) else: relative_path = filename diff = difflib.unified_diff(original_txt.splitlines(False), From 741591191e3da6af8d06e28e4058184c05f796ad Mon Sep 17 00:00:00 2001 From: Josselin Date: Thu, 27 Jun 2019 12:11:29 +0200 Subject: [PATCH 074/223] slither-format: generate floating solc version --- utils/slither_format/formatters/pragma.py | 2 +- utils/slither_format/formatters/solc_version.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/utils/slither_format/formatters/pragma.py b/utils/slither_format/formatters/pragma.py index 737aa8fe7..9a19f9f82 100644 --- a/utils/slither_format/formatters/pragma.py +++ b/utils/slither_format/formatters/pragma.py @@ -3,7 +3,7 @@ from slither.exceptions import SlitherException from ..utils.patches import create_patch # Indicates the recommended versions for replacement -REPLACEMENT_VERSIONS = ["0.4.25", "0.5.3"] +REPLACEMENT_VERSIONS = ["^0.4.25", "^0.5.3"] # group: # 0: ^ > >= < <= (optional) diff --git a/utils/slither_format/formatters/solc_version.py b/utils/slither_format/formatters/solc_version.py index ead6cad97..fd9d7822d 100644 --- a/utils/slither_format/formatters/solc_version.py +++ b/utils/slither_format/formatters/solc_version.py @@ -4,7 +4,7 @@ from ..utils.patches import create_patch # Indicates the recommended versions for replacement -REPLACEMENT_VERSIONS = ["0.4.25", "0.5.3"] +REPLACEMENT_VERSIONS = ["^0.4.25", "^0.5.3"] # group: # 0: ^ > >= < <= (optional) From c34ecd4320608d23527585a7f3205affe06f699e Mon Sep 17 00:00:00 2001 From: Feist Josselin Date: Thu, 27 Jun 2019 15:01:34 +0200 Subject: [PATCH 075/223] Update CONTRIBUTING.md --- CONTRIBUTING.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index c5b078541..8e767e47c 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -1,4 +1,4 @@ -# Contributing to Manticore +# Contributing to Slither First, thanks for your interest in contributing to Slither! We welcome and appreciate all contributions, including bug reports, feature suggestions, tutorials/blog posts, and code improvements. If you're unsure where to start, we recommend our [`good first issue`](https://github.com/crytic/slither/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22) and [`help wanted`](https://github.com/crytic/slither/issues?q=is%3Aissue+is%3Aopen+label%3A%22help+wanted%22) issue labels. From ba8827599294deaf9cdfe262b06e0d0e93ee00f9 Mon Sep 17 00:00:00 2001 From: Josselin Date: Thu, 27 Jun 2019 16:12:03 +0200 Subject: [PATCH 076/223] Naming convention detector: Allow _ for private/internal function Naming convention format: fix incorrect file access --- .../naming_convention/naming_convention.py | 2 ++ .../formatters/naming_convention.py | 35 +++++++++++-------- 2 files changed, 23 insertions(+), 14 deletions(-) diff --git a/slither/detectors/naming_convention/naming_convention.py b/slither/detectors/naming_convention/naming_convention.py index 9c69e41ba..7c2d5fe29 100644 --- a/slither/detectors/naming_convention/naming_convention.py +++ b/slither/detectors/naming_convention/naming_convention.py @@ -93,6 +93,8 @@ Solidity defines a [naming convention](https://solidity.readthedocs.io/en/v0.4.2 for func in contract.functions_declared: if not self.is_mixed_case(func.name): + if func.visibility in ['internal', 'private'] and self.is_mixed_case_with_underscore(func.name): + continue info = "Function '{}' ({}) is not in mixedCase\n" info = info.format(func.canonical_name, func.source_mapping_str) diff --git a/utils/slither_format/formatters/naming_convention.py b/utils/slither_format/formatters/naming_convention.py index 761aa13d3..6b4f3ec7b 100644 --- a/utils/slither_format/formatters/naming_convention.py +++ b/utils/slither_format/formatters/naming_convention.py @@ -305,7 +305,8 @@ def _create_patch_event_definition(slither, result, element): if event.name == name: # Get only event name without parameters event_name = name.split('(')[0] - in_file_str = slither.source_code[in_file].encode('utf-8') + f_event = event.source_mapping['filename_absolute'] + in_file_str = slither.source_code[f_event].encode('utf-8') old_str_of_interest = in_file_str[loc_start:loc_end] # Capitalize event name (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"event"+r'(.*)'+event_name, r'\1'+"event"+r'\2' + @@ -313,7 +314,7 @@ def _create_patch_event_definition(slither, result, element): old_str_of_interest.decode('utf-8'), 1) if num_repl != 0: create_patch(result, - in_file, + f_event, loc_start, loc_end, old_str_of_interest.decode('utf-8'), @@ -439,7 +440,8 @@ def _create_patch_modifier_uses(slither, result, element): for function in target_contract.functions: for m in function.modifiers: if (m == modifier_contract): - in_file_str = slither.source_code[in_file].encode('utf-8') + f_modifier = m.source_mapping['filename_absolute'] + in_file_str = slither.source_code[f_modifier].encode('utf-8') # Get the text from function parameters until the return statement or function body beginning # This text will include parameter declarations, any Solidity keywords and modifier call # Parameter names cannot collide with modifier name per Solidity rules @@ -450,7 +452,7 @@ def _create_patch_modifier_uses(slither, result, element): old_str_of_interest.decode('utf-8'),1) if num_repl != 0: create_patch(result, - in_file, + f_modifier, int(function.parameters_src.source_mapping['start']), int(function.returns_src.source_mapping['start']), old_str_of_interest.decode('utf-8'), @@ -475,7 +477,8 @@ def _create_patch_function_calls(slither, result, element): # Check the called function name called_function = str(external_call.called).split('.')[-1] if called_function == high_level_call[1].name: - in_file_str = slither.source_code[in_file].encode('utf-8') + f_external_call = external_call.source_mapping['filename_absolute'] + in_file_str = slither.source_code[f_external_call].encode('utf-8') old_str_of_interest = in_file_str[int(external_call.source_mapping['start']): int(external_call.source_mapping['start']) + int(external_call.source_mapping['length'])] @@ -487,7 +490,7 @@ def _create_patch_function_calls(slither, result, element): new_string = '.'.join(old_str_of_interest.decode('utf-8').split('.')[:-1]) + '.' + \ fixed_function_name create_patch(result, - in_file, + f_external_call, external_call.source_mapping['start'], int(external_call.source_mapping['start']) + int(external_call.source_mapping['length']), @@ -496,7 +499,8 @@ def _create_patch_function_calls(slither, result, element): # Function call from within same contract for internal_call in node.internal_calls_as_expressions: if (str(internal_call.called) == name): - in_file_str = slither.source_code[in_file].encode('utf-8') + f_internal_call = internal_call.source_mapping['filename_absolute'] + in_file_str = slither.source_code[f_internal_call].encode('utf-8') old_str_of_interest = in_file_str[int(internal_call.source_mapping['start']): int(internal_call.source_mapping['start']) + int(internal_call.source_mapping['length'])] @@ -511,7 +515,7 @@ def _create_patch_function_calls(slither, result, element): int(internal_call.source_mapping['length'])] \ .decode('utf-8').split('(')[1:])) - 1 create_patch(result, - in_file, + f_internal_call, internal_call.source_mapping['start'], end_loc, old_str_of_interest, @@ -536,13 +540,14 @@ def _create_patch_event_calls(slither, result, element): for node in function.nodes: for call in node.internal_calls_as_expressions: if (str(call.called) == event_name): - in_file_str = slither.source_code[in_file].encode('utf-8') + f_call = call.source_mapping['filename_absolute'] + in_file_str = slither.source_code[f_call].encode('utf-8') old_str_of_interest = in_file_str[int(call.source_mapping['start']): int(call.source_mapping['start']) + int(call.source_mapping['length'])] create_patch(result, - in_file, + f_call, call.source_mapping['start'], int(call.source_mapping['start']) + int(call.source_mapping['length']), old_str_of_interest.decode('utf-8'), @@ -658,7 +663,8 @@ def _create_patch_state_variable_uses(slither, result, element): if str(sv) == name]: modify_loc_start = int(v.source_mapping['start']) modify_loc_end = int(v.source_mapping['start']) + int(v.source_mapping['length']) - in_file_str = slither.source_code[in_file].encode('utf-8') + f_function = fm.source_mapping['filename_absolute'] + in_file_str = slither.f_function[f_function].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] if (element['additional_fields']['target'] == "variable_constant"): # Convert constant state variables to upper case @@ -668,7 +674,7 @@ def _create_patch_state_variable_uses(slither, result, element): new_str_of_interest = new_str_of_interest[0].lower()+new_str_of_interest[1:] create_patch(result, - in_file, + f_function, modify_loc_start, modify_loc_end, old_str_of_interest.decode('utf-8'), @@ -783,7 +789,8 @@ def _create_patch_struct_uses(slither, result, element): raise SlitherException(f"Contract not found {contract_name}") for contract in [target_contract] + target_contract.derived_contracts: - in_file_str = slither.source_code[in_file].encode('utf-8') + f_contract = contract.source_mapping['filename_absolute'] + in_file_str = slither.source_code[f_contract].encode('utf-8') # Check state variables of struct type # To-do: Deep-check aggregate types (struct and mapping) svs = contract.variables @@ -795,7 +802,7 @@ def _create_patch_struct_uses(slither, result, element): old_str_of_interest.decode('utf-8'), 1) create_patch(result, - in_file, + f_contract, sv.source_mapping['start'], sv.source_mapping['start'] + sv.source_mapping['length'], old_str_of_interest.decode('utf-8'), From 91b8b7da933e7a13e790a7a0c8861a961239001f Mon Sep 17 00:00:00 2001 From: Josselin Date: Thu, 27 Jun 2019 16:17:51 +0200 Subject: [PATCH 077/223] Fix typo --- utils/slither_format/formatters/naming_convention.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/utils/slither_format/formatters/naming_convention.py b/utils/slither_format/formatters/naming_convention.py index 6b4f3ec7b..2daa22530 100644 --- a/utils/slither_format/formatters/naming_convention.py +++ b/utils/slither_format/formatters/naming_convention.py @@ -664,7 +664,7 @@ def _create_patch_state_variable_uses(slither, result, element): modify_loc_start = int(v.source_mapping['start']) modify_loc_end = int(v.source_mapping['start']) + int(v.source_mapping['length']) f_function = fm.source_mapping['filename_absolute'] - in_file_str = slither.f_function[f_function].encode('utf-8') + in_file_str = slither.source_code[f_function].encode('utf-8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] if (element['additional_fields']['target'] == "variable_constant"): # Convert constant state variables to upper case From 80db6cc543136fed39967827fe08bdf849d49c30 Mon Sep 17 00:00:00 2001 From: Josselin Date: Thu, 27 Jun 2019 19:00:12 +0200 Subject: [PATCH 078/223] slither-format: improve error handling --- utils/slither_format/exceptions.py | 5 +++ .../formatters/constable_states.py | 4 +- .../formatters/constant_function.py | 4 +- .../formatters/naming_convention.py | 45 +++++++++---------- utils/slither_format/formatters/pragma.py | 6 +-- .../slither_format/formatters/solc_version.py | 4 +- utils/slither_format/slither_format.py | 40 ++++++++--------- 7 files changed, 55 insertions(+), 53 deletions(-) create mode 100644 utils/slither_format/exceptions.py diff --git a/utils/slither_format/exceptions.py b/utils/slither_format/exceptions.py new file mode 100644 index 000000000..eac7df205 --- /dev/null +++ b/utils/slither_format/exceptions.py @@ -0,0 +1,5 @@ +from slither.exceptions import SlitherException + +class FormatImpossible(SlitherException): pass + +class FormatError(SlitherException): pass diff --git a/utils/slither_format/formatters/constable_states.py b/utils/slither_format/formatters/constable_states.py index aa275bdf6..f07dd8c3a 100644 --- a/utils/slither_format/formatters/constable_states.py +++ b/utils/slither_format/formatters/constable_states.py @@ -1,5 +1,5 @@ import re -from slither.exceptions import SlitherException +from ..exceptions import FormatError from ..utils.patches import create_patch def format(slither, result): @@ -26,5 +26,5 @@ def _patch(slither, result, in_file, match_text, replace_text, modify_loc_start, new_str_of_interest) else: - raise SlitherException("State variable not found?!") + raise FormatError("State variable not found?!") diff --git a/utils/slither_format/formatters/constant_function.py b/utils/slither_format/formatters/constant_function.py index 22c538baf..23939acbc 100644 --- a/utils/slither_format/formatters/constant_function.py +++ b/utils/slither_format/formatters/constant_function.py @@ -1,5 +1,5 @@ import re -from slither.exceptions import SlitherException +from ..exceptions import FormatError from ..utils.patches import create_patch def format(slither, patches, elements): @@ -32,4 +32,4 @@ def _patch(slither, patches, in_file, in_file_relative, modify_loc_start, modify m.groups(0)[0], # this is view|pure|constant "") else: - raise SlitherException("No view/pure/constant specifier exists. Regex failed to remove specifier!") + raise FormatError("No view/pure/constant specifier exists. Regex failed to remove specifier!") diff --git a/utils/slither_format/formatters/naming_convention.py b/utils/slither_format/formatters/naming_convention.py index 2daa22530..3c2060e3a 100644 --- a/utils/slither_format/formatters/naming_convention.py +++ b/utils/slither_format/formatters/naming_convention.py @@ -1,10 +1,9 @@ import re import logging -from collections import namedtuple -from slither.exceptions import SlitherException from slither.core.expressions.identifier import Identifier from slither.slithir.operations import NewContract from slither.slithir.operations import Member +from ..exceptions import FormatError from ..utils.patches import create_patch logging.basicConfig(level=logging.INFO) @@ -102,7 +101,7 @@ def _patch(slither, result, element, _target): _create_patch_modifier_uses(slither, result, element) else: - raise SlitherException("Unknown naming convention! " + _target) + raise FormatError("Unknown naming convention! " + _target) # endregion ################################################################################### @@ -127,7 +126,7 @@ def _create_patch_contract_definition(slither, result, element): old_str_of_interest.decode('utf-8'), 1) if num_repl == 0: - raise SlitherException(f"Could not find contract: {name}") + raise FormatError(f"Could not find contract: {name}") old_string = old_str_of_interest.decode('utf-8') @@ -206,7 +205,7 @@ def _create_patch_enum_declaration(slither, result, element): old_str_of_interest.decode('utf-8'), 1) if num_repl == 0: - raise SlitherException(f"Could not find enum: {name}") + raise FormatError(f"Could not find enum: {name}") old_string = old_str_of_interest.decode('utf-8') @@ -234,7 +233,7 @@ def _create_patch_struct_definition(slither, result, element): old_str_of_interest.decode('utf-8'), 1) if num_repl == 0: - raise SlitherException(f"Could not find struct: {name}") + raise FormatError(f"Could not find struct: {name}") old_string = old_str_of_interest.decode('utf-8') @@ -266,7 +265,7 @@ def _create_patch_modifier_definition(slither, result, element): old_str_of_interest.decode('utf-8'), new_str_of_interest) else: - raise SlitherException("Could not find modifier?!") + raise FormatError(f"Could not find modifier {name}") def _create_patch_function_definition(slither, result, element): @@ -290,7 +289,7 @@ def _create_patch_function_definition(slither, result, element): new_str_of_interest) else: - raise SlitherException(f"Could not find function {name}") + raise FormatError(f"Could not find function {name}") def _create_patch_event_definition(slither, result, element): in_file, in_file_str, old_str_of_interest, loc_start, loc_end = _unpack_info(slither, element) @@ -300,7 +299,7 @@ def _create_patch_event_definition(slither, result, element): target_contract = slither.get_contract_from_name(contract_name) if not target_contract: - raise SlitherException("Contract not found?!") + raise FormatError(f"Contract not found {contract_name}") for event in target_contract.events: if event.name == name: # Get only event name without parameters @@ -320,7 +319,7 @@ def _create_patch_event_definition(slither, result, element): old_str_of_interest.decode('utf-8'), new_str_of_interest) else: - raise SlitherException("Could not find event?!") + raise FormatError(f"Could not find event {name}") def _create_patch_parameter_declaration(slither, result, element): in_file, in_file_str, old_str_of_interest, loc_start, loc_end = _unpack_info(slither, element) @@ -343,7 +342,7 @@ def _create_patch_parameter_declaration(slither, result, element): old_str_of_interest.decode('utf-8'), new_str_of_interest) else: - raise SlitherException("Could not find parameter declaration?!") + raise FormatError(f"Could not find parameter declaration {name}") # endregion ################################################################################### @@ -359,7 +358,7 @@ def _create_patch_contract_uses(slither, result, element): target_contract = slither.get_contract_from_name(name) if not target_contract: - raise SlitherException(f"Contract not found {name}") + raise FormatError(f"Contract not found {name}") # Check state variables of contract type # To-do: Deep-check aggregate types (struct and mapping) @@ -420,7 +419,7 @@ def _create_patch_contract_uses(slither, result, element): old_str_of_interest, new_str_of_interest) else: - raise SlitherException("Could not find new object?!") + raise FormatError(f"Could not find new object {name}") def _create_patch_modifier_uses(slither, result, element): @@ -433,7 +432,7 @@ def _create_patch_modifier_uses(slither, result, element): target_contract = slither.get_contract_from_name(contract_name) if not target_contract: - raise SlitherException("Contract not found?!") + raise FormatError(f"Contract not found {contract_name}") modifier_contract = target_contract.get_modifier_from_signature(modifier_sig) @@ -458,7 +457,7 @@ def _create_patch_modifier_uses(slither, result, element): old_str_of_interest.decode('utf-8'), new_str_of_interest) else: - raise SlitherException("Could not find modifier name?!") + raise FormatError(f"Could not find modifier {modifier_sig}") @@ -534,7 +533,7 @@ def _create_patch_event_calls(slither, result, element): event_name = name.split('(')[0] target_contract = slither.get_contract_from_name(contract_name) if not target_contract: - raise SlitherException("Contract not found?!") + raise FormatError(f"Contract not found {name}") for contract in [target_contract] + target_contract.derived_contracts: for function in contract.functions: for node in function.nodes: @@ -602,7 +601,7 @@ def _create_patch_parameter_uses(slither, result, element): old_str_of_interest.decode('utf-8'), new_str_of_interest) else: - raise SlitherException("Could not find parameter use?!") + raise FormatError(f"Could not find parameter use {name}") # Process function parameters passed to modifiers # _expression_modifiers is used to access the source mapping of the call rather @@ -637,20 +636,18 @@ def _create_patch_parameter_uses(slither, result, element): old_str_of_interest_beyond_modifier_name, new_str_of_interest) else: - raise SlitherException("Could not find parameter use in modifier?!") + raise FormatError(f"Could not find parameter use in modifier {modifier}") def _create_patch_state_variable_uses(slither, result, element): - in_file, in_file_str, old_str_of_interest, loc_start, loc_end = _unpack_info(slither, element) - name = get_name(element) contract_name = get_contract_name(element) # To-do: Check cross-contract state variable uses target_contract = slither.get_contract_from_name(contract_name) if not target_contract: - raise SlitherException(f"Contract not found {contract_name}") + raise FormatError(f"Contract not found {contract_name}") fms = target_contract.functions + target_contract.modifiers for fm in fms: @@ -690,7 +687,7 @@ def _create_patch_enum_uses(slither, result, element): target_contract = slither.get_contract_from_name(contract_name) if not target_contract: - raise SlitherException(f"Contract not found {contract_name}") + raise FormatError(f"Contract not found {contract_name}") in_file_str = slither.source_code[in_file].encode('utf-8') # Check state variable declarations of enum type @@ -771,7 +768,7 @@ def _create_patch_enum_uses(slither, result, element): new_str_of_interest) else: - raise SlitherException("Could not find new object?!") + raise FormatError(f"Could not find new object {function}") # To-do: Check any other place/way where enum type is used @@ -786,7 +783,7 @@ def _create_patch_struct_uses(slither, result, element): target_contract = slither.get_contract_from_name(contract_name) if not target_contract: - raise SlitherException(f"Contract not found {contract_name}") + raise FormatError(f"Contract not found {contract_name}") for contract in [target_contract] + target_contract.derived_contracts: f_contract = contract.source_mapping['filename_absolute'] diff --git a/utils/slither_format/formatters/pragma.py b/utils/slither_format/formatters/pragma.py index 9a19f9f82..57f01b3c9 100644 --- a/utils/slither_format/formatters/pragma.py +++ b/utils/slither_format/formatters/pragma.py @@ -1,5 +1,5 @@ import re -from slither.exceptions import SlitherException +from ..exceptions import FormatImpossible from ..utils.patches import create_patch # Indicates the recommended versions for replacement @@ -31,7 +31,7 @@ def _analyse_versions(used_solc_versions): for version in used_solc_versions: replace_solc_versions.append(_determine_solc_version_replacement(version)) if not all(version == replace_solc_versions[0] for version in replace_solc_versions): - raise SlitherException("Multiple incompatible versions!") + raise FormatImpossible("Multiple incompatible versions!") else: return replace_solc_versions[0] @@ -46,7 +46,7 @@ def _determine_solc_version_replacement(used_solc_version): elif minor_version == '5': return "pragma solidity " + REPLACEMENT_VERSIONS[1] + ';' else: - raise SlitherException("Unknown version!") + raise FormatImpossible("Unknown version!") elif len(versions) == 2: version_right = versions[1] minor_version_right = '.'.join(version_right[2:])[2] diff --git a/utils/slither_format/formatters/solc_version.py b/utils/slither_format/formatters/solc_version.py index fd9d7822d..fe7b3fe27 100644 --- a/utils/slither_format/formatters/solc_version.py +++ b/utils/slither_format/formatters/solc_version.py @@ -1,5 +1,5 @@ import re -from slither.exceptions import SlitherException +from ..exceptions import FormatImpossible from ..utils.patches import create_patch @@ -36,7 +36,7 @@ def _determine_solc_version_replacement(used_solc_version): # Replace with 0.5.3 return "pragma solidity " + REPLACEMENT_VERSIONS[1] + ';' else: - raise SlitherException("Unknown version!") + raise FormatImpossible(f"Unknown version {versions}") elif len(versions) == 2: version_right = versions[1] minor_version_right = '.'.join(version_right[2:])[2] diff --git a/utils/slither_format/slither_format.py b/utils/slither_format/slither_format.py index c94712255..e2190671c 100644 --- a/utils/slither_format/slither_format.py +++ b/utils/slither_format/slither_format.py @@ -1,7 +1,5 @@ -import sys import logging import os -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 @@ -11,10 +9,10 @@ from slither.detectors.variables.possible_const_state_variables import ConstCand from slither.detectors.attributes.const_functions import ConstantFunctions from .formatters import unused_state, constable_states, pragma, solc_version, external_function, naming_convention from .utils.patches import apply_patch, create_diff +from .exceptions import FormatError, FormatImpossible logging.basicConfig(level=logging.INFO) logger = logging.getLogger('Slither.Format') -set_colorization_enabled(True) all_detectors = { 'unused-state': UnusedStateVars, @@ -99,23 +97,25 @@ def apply_detector_results(slither, detector_results): Apply slither detector results on contract files to generate patches ''' for result in detector_results: - if result['check'] == 'unused-state': - unused_state.format(slither, result) - elif result['check'] == 'solc-version': - solc_version.format(slither, result) - elif result['check'] == 'pragma': - pragma.format(slither, result) - elif result['check'] == 'naming-convention': - naming_convention.format(slither, result) - elif result['check'] == 'external-function': - external_function.format(slither, result) - elif result['check'] == 'constable-states': - constable_states.format(slither, result) - elif result['check'] == 'constant-function': - constable_states.format(slither, result) - else: - logger.error(red(result['check'] + "detector not supported yet.")) - sys.exit(-1) + try: + if result['check'] == 'unused-state': + unused_state.format(slither, result) + elif result['check'] == 'solc-version': + solc_version.format(slither, result) + elif result['check'] == 'pragma': + pragma.format(slither, result) + elif result['check'] == 'naming-convention': + naming_convention.format(slither, result) + elif result['check'] == 'external-function': + external_function.format(slither, result) + elif result['check'] == 'constable-states': + constable_states.format(slither, result) + elif result['check'] == 'constant-function': + constable_states.format(slither, result) + else: + raise FormatError(result['check'] + "detector not supported yet.") + except FormatImpossible as e: + logger.info(f'Impossible to patch:\n{result["description"]}\nReason: {e}') # endregion From 4330b9421acae18d7f790f6a0534f1dafa2d9681 Mon Sep 17 00:00:00 2001 From: Josselin Date: Fri, 28 Jun 2019 09:13:55 +0200 Subject: [PATCH 079/223] slither-format: add --exclude flag --- utils/slither_format/__main__.py | 8 ++++++++ utils/slither_format/slither_format.py | 14 ++++++++++++-- 2 files changed, 20 insertions(+), 2 deletions(-) diff --git a/utils/slither_format/__main__.py b/utils/slither_format/__main__.py index d2ebfacfa..992969dc4 100644 --- a/utils/slither_format/__main__.py +++ b/utils/slither_format/__main__.py @@ -50,6 +50,14 @@ def parse_args(): dest='detectors_to_run', default='all') + group_detector.add_argument('--exclude', + help='Comma-separated list of detectors to exclude,' + 'available detectors: {}'.format( + ', '.join(d for d in available_detectors)), + action='store', + dest='detectors_to_exclude', + default='all') + cryticparser.init(parser) if len(sys.argv) == 1: diff --git a/utils/slither_format/slither_format.py b/utils/slither_format/slither_format.py index e2190671c..458649579 100644 --- a/utils/slither_format/slither_format.py +++ b/utils/slither_format/slither_format.py @@ -30,7 +30,8 @@ def slither_format(slither, **kwargs): detectors_to_run (str): Comma-separated list of detectors, defaults to all ''' - detectors_to_run = choose_detectors(kwargs.get('detectors_to_run', 'all')) + detectors_to_run = choose_detectors(kwargs.get('detectors_to_run', 'all'), + kwargs.get('detectors_to_exclude', '')) for detector in detectors_to_run: slither.register_detector(detector) @@ -64,6 +65,9 @@ def slither_format(slither, **kwargs): result['paches_diff'] = diff if skip_file_generation: continue + if not diff: + logger.info(f'Empty patch generated {result}') + continue path = os.path.join(export, f'fix_{counter}.patch') logger.info(f'\t- {path}') with open(path, 'w') as f: @@ -78,15 +82,21 @@ def slither_format(slither, **kwargs): ################################################################################### ################################################################################### -def choose_detectors(detectors_to_run): +def choose_detectors(detectors_to_run, detectors_to_exclude): # If detectors are specified, run only these ones cls_detectors_to_run = [] + exclude = detectors_to_exclude.split(',') if detectors_to_run == 'all': for d in all_detectors: + if d in exclude: + continue cls_detectors_to_run.append(all_detectors[d]) else: + exclude = detectors_to_exclude.split(',') for d in detectors_to_run.split(','): if d in all_detectors: + if d in exclude: + continue cls_detectors_to_run.append(all_detectors[d]) else: raise Exception('Error: {} is not a detector'.format(d)) From bb57e940c30e757c18c6eb2e775f63ed6d175f38 Mon Sep 17 00:00:00 2001 From: Josselin Date: Fri, 28 Jun 2019 09:43:32 +0200 Subject: [PATCH 080/223] Factorise config parsing + add config parsing to slither-format --- slither/__main__.py | 41 +++------------------------- slither/utils/command_line.py | 46 +++++++++++++++++++++++++++++++- utils/slither_format/__main__.py | 17 +++++++++--- 3 files changed, 62 insertions(+), 42 deletions(-) diff --git a/slither/__main__.py b/slither/__main__.py index 5a0563fa3..0a26f8ff6 100644 --- a/slither/__main__.py +++ b/slither/__main__.py @@ -6,7 +6,6 @@ import inspect import json import logging import os -import subprocess import sys import traceback @@ -22,7 +21,8 @@ from slither.slither import Slither from slither.utils.colors import red, yellow, set_colorization_enabled from slither.utils.command_line import (output_detectors, output_results_to_markdown, output_detectors_json, output_printers, - output_to_markdown, output_wiki) + output_to_markdown, output_wiki, defaults_flag_in_config, + read_config_file) from crytic_compile import is_supported from slither.exceptions import SlitherException @@ -253,30 +253,6 @@ def parse_filter_paths(args): return args.filter_paths.split(',') return [] -# Those are the flags shared by the command line and the config file -defaults_flag_in_config = { - 'detectors_to_run': 'all', - 'printers_to_run': None, - 'detectors_to_exclude': None, - 'exclude_informational': False, - 'exclude_low': False, - 'exclude_medium': False, - 'exclude_high': False, - 'solc': 'solc', - 'solc_args': None, - 'disable_solc_warnings': False, - 'json': None, - 'truffle_version': None, - 'disable_color': False, - 'filter_paths': None, - 'truffle_ignore_compile': False, - 'truffle_build_directory': 'build/contracts', - 'embark_ignore_compile': False, - 'embark_overwrite_config': False, - # debug command - 'legacy_ast': False, - 'ignore_return_value': False - } def parse_args(detector_classes, printer_classes): parser = argparse.ArgumentParser(description='Slither. For usage information, see https://github.com/crytic/slither/wiki/Usage', @@ -435,18 +411,7 @@ def parse_args(detector_classes, printer_classes): args = parser.parse_args() - if os.path.isfile(args.config_file): - try: - with open(args.config_file) as f: - config = json.load(f) - for key, elem in config.items(): - if key not in defaults_flag_in_config: - logger.info(yellow('{} has an unknown key: {} : {}'.format(args.config_file, key, elem))) - continue - if getattr(args, key) == defaults_flag_in_config[key]: - setattr(args, key, elem) - except json.decoder.JSONDecodeError as e: - logger.error(red('Impossible to read {}, please check the file {}'.format(args.config_file, e))) + read_config_file(args) return args diff --git a/slither/utils/command_line.py b/slither/utils/command_line.py index d1a495a23..04bf812d9 100644 --- a/slither/utils/command_line.py +++ b/slither/utils/command_line.py @@ -1,9 +1,53 @@ import json +import os +import logging from collections import defaultdict from prettytable import PrettyTable - +from .colors import yellow, red from slither.detectors.abstract_detector import classification_txt +logger = logging.getLogger("Slither") + +# Those are the flags shared by the command line and the config file +defaults_flag_in_config = { + 'detectors_to_run': 'all', + 'printers_to_run': None, + 'detectors_to_exclude': None, + 'exclude_informational': False, + 'exclude_low': False, + 'exclude_medium': False, + 'exclude_high': False, + 'solc': 'solc', + 'solc_args': None, + 'disable_solc_warnings': False, + 'json': None, + 'truffle_version': None, + 'disable_color': False, + 'filter_paths': None, + 'truffle_ignore_compile': False, + 'truffle_build_directory': 'build/contracts', + 'embark_ignore_compile': False, + 'embark_overwrite_config': False, + # debug command + 'legacy_ast': False, + 'ignore_return_value': False + } + +def read_config_file(args): + if os.path.isfile(args.config_file): + try: + with open(args.config_file) as f: + config = json.load(f) + for key, elem in config.items(): + if key not in defaults_flag_in_config: + logger.info(yellow('{} has an unknown key: {} : {}'.format(args.config_file, key, elem))) + continue + if getattr(args, key) == defaults_flag_in_config[key]: + setattr(args, key, elem) + except json.decoder.JSONDecodeError as e: + logger.error(red('Impossible to read {}, please check the file {}'.format(args.config_file, e))) + + def output_to_markdown(detector_classes, printer_classes, filter_wiki): def extract_help(cls): diff --git a/utils/slither_format/__main__.py b/utils/slither_format/__main__.py index 992969dc4..c3e01bf76 100644 --- a/utils/slither_format/__main__.py +++ b/utils/slither_format/__main__.py @@ -1,13 +1,13 @@ -import os, sys +import sys import argparse from slither import Slither -from slither.utils.colors import red +from slither.utils.command_line import read_config_file import logging from .slither_format import slither_format from crytic_compile import cryticparser logging.basicConfig() -logging.getLogger("Slither").setLevel(logging.INFO) +logger = logging.getLogger("Slither").setLevel(logging.INFO) # Slither detectors for which slither-format currently works available_detectors = ["unused-state", @@ -40,6 +40,14 @@ def parse_args(): help='Do not generate patch files', action='store_true', default=False) + + + parser.add_argument('--config-file', + help='Provide a config file (default: slither.config.json)', + action='store', + dest='config_file', + default='slither.config.json') + group_detector = parser.add_argument_group('Detectors') group_detector.add_argument('--detect', @@ -75,6 +83,9 @@ def main(): # Parse all arguments args = parse_args() + read_config_file(args) + + # Perform slither analysis on the given filename slither = Slither(args.filename, **vars(args)) From 2ac8827e9973476f91a12e5aab5d5e889a9d0034 Mon Sep 17 00:00:00 2001 From: Josselin Date: Fri, 28 Jun 2019 10:49:42 +0200 Subject: [PATCH 081/223] Minor --- utils/slither_format/formatters/external_function.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/utils/slither_format/formatters/external_function.py b/utils/slither_format/formatters/external_function.py index 28db15f24..ec5e160f8 100644 --- a/utils/slither_format/formatters/external_function.py +++ b/utils/slither_format/formatters/external_function.py @@ -37,6 +37,6 @@ def _patch(slither, result, in_file, modify_loc_start, modify_loc_end): # start at the keyword `public` modify_loc_start + m.span()[0] + 1, # end after the keyword `public` = start + len('public'') - modify_loc_start + m.span()[0] + 1 + 6, - " public", - " external") + modify_loc_start + m.span()[0] + 1 + len('public'), + "public", + "external") From cb375eeb80199164454018f16a5dbe73fe385c42 Mon Sep 17 00:00:00 2001 From: Josselin Date: Fri, 28 Jun 2019 10:58:47 +0200 Subject: [PATCH 082/223] naming convention detector: Fix is_mixed_case with _ --- slither/detectors/naming_convention/naming_convention.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/slither/detectors/naming_convention/naming_convention.py b/slither/detectors/naming_convention/naming_convention.py index 7c2d5fe29..6c72f4438 100644 --- a/slither/detectors/naming_convention/naming_convention.py +++ b/slither/detectors/naming_convention/naming_convention.py @@ -41,7 +41,7 @@ Solidity defines a [naming convention](https://solidity.readthedocs.io/en/v0.4.2 def is_mixed_case_with_underscore(name): # Allow _ at the beginning to represent private variable # or unused parameters - return re.search('^[a-z_]([A-Za-z0-9]+)?_?$', name) is not None + return re.search('^[_]?[a-z]([A-Za-z0-9]+)?_?$', name) is not None @staticmethod def is_upper_case_with_underscores(name): From a4428211a31dd214ec03f2badcb83d90b70d1655 Mon Sep 17 00:00:00 2001 From: Josselin Date: Mon, 1 Jul 2019 12:44:10 +0200 Subject: [PATCH 083/223] Improve naming convetion formater + add ReadVarSyntactic visitor --- slither/core/children/child_expression.py | 0 .../visitors/expression/read_var_syntactic.py | 105 ++++++++++++++++++ .../formatters/naming_convention.py | 30 ++++- utils/slither_format/utils/usages.py | 0 4 files changed, 134 insertions(+), 1 deletion(-) create mode 100644 slither/core/children/child_expression.py create mode 100644 slither/visitors/expression/read_var_syntactic.py create mode 100644 utils/slither_format/utils/usages.py diff --git a/slither/core/children/child_expression.py b/slither/core/children/child_expression.py new file mode 100644 index 000000000..e69de29bb diff --git a/slither/visitors/expression/read_var_syntactic.py b/slither/visitors/expression/read_var_syntactic.py new file mode 100644 index 000000000..92cfd4ae9 --- /dev/null +++ b/slither/visitors/expression/read_var_syntactic.py @@ -0,0 +1,105 @@ + +from slither.visitors.expression.expression import ExpressionVisitor + +from slither.core.expressions.assignment_operation import AssignmentOperationType + +from slither.core.variables.variable import Variable +from slither.core.declarations.solidity_variables import SolidityVariable + +key = 'ReadVarSyntactic' + +def get(expression): + val = expression.context[key] + # we delete the item to reduce memory use + del expression.context[key] + return val + +def set_val(expression, val): + expression.context[key] = val + +# This Visitor is similar to ReadVar +# Except that it does explore all assignements operations +# Read is in the context of source code read, rather than semantic-based read +class ReadVarSyntactic(ExpressionVisitor): + + def result(self): + if self._result is None: + self._result = list(set(get(self.expression))) + return self._result + + + def _post_assignement_operation(self, expression): + left = get(expression.expression_left) + right = get(expression.expression_right) + val = left + right + set_val(expression, val) + + def _post_binary_operation(self, expression): + left = get(expression.expression_left) + right = get(expression.expression_right) + val = left + right + set_val(expression, val) + + def _post_call_expression(self, expression): + called = get(expression.called) + args = [get(a) for a in expression.arguments if a] + args = [item for sublist in args for item in sublist] + val = called + args + set_val(expression, val) + + def _post_conditional_expression(self, expression): + if_expr = get(expression.if_expression) + else_expr = get(expression.else_expression) + then_expr = get(expression.then_expression) + val = if_expr + else_expr + then_expr + set_val(expression, val) + + def _post_elementary_type_name_expression(self, expression): + set_val(expression, []) + + # save only identifier expression + def _post_identifier(self, expression): + if isinstance(expression.value, Variable): + set_val(expression, [expression]) + elif isinstance(expression.value, SolidityVariable): + set_val(expression, [expression]) + else: + set_val(expression, []) + + def _post_index_access(self, expression): + left = get(expression.expression_left) + right = get(expression.expression_right) + val = left + right + [expression] + set_val(expression, val) + + def _post_literal(self, expression): + set_val(expression, []) + + def _post_member_access(self, expression): + expr = get(expression.expression) + val = expr + set_val(expression, val) + + def _post_new_array(self, expression): + set_val(expression, []) + + def _post_new_contract(self, expression): + set_val(expression, []) + + def _post_new_elementary_type(self, expression): + set_val(expression, []) + + def _post_tuple_expression(self, expression): + expressions = [get(e) for e in expression.expressions if e] + val = [item for sublist in expressions for item in sublist] + set_val(expression, val) + + def _post_type_conversion(self, expression): + expr = get(expression.expression) + val = expr + set_val(expression, val) + + def _post_unary_operation(self, expression): + expr = get(expression.expression) + val = expr + set_val(expression, val) diff --git a/utils/slither_format/formatters/naming_convention.py b/utils/slither_format/formatters/naming_convention.py index 3c2060e3a..307613b78 100644 --- a/utils/slither_format/formatters/naming_convention.py +++ b/utils/slither_format/formatters/naming_convention.py @@ -1,8 +1,11 @@ import re import logging from slither.core.expressions.identifier import Identifier +from slither.core.declarations import Structure +from slither.core.solidity_types import UserDefinedType from slither.slithir.operations import NewContract from slither.slithir.operations import Member +from slither.visitors.expression.read_var_syntactic import ReadVarSyntactic from ..exceptions import FormatError from ..utils.patches import create_patch @@ -652,7 +655,10 @@ def _create_patch_state_variable_uses(slither, result, element): fms = target_contract.functions + target_contract.modifiers for fm in fms: for node in fm.nodes: - vars = node._expression_vars_written + node._expression_vars_read + if not node.expression: + continue + visitor = ReadVarSyntactic(node.expression) + vars = visitor.result() for v in vars: if isinstance(v, Identifier) and str(v) == name and [str(sv) for sv in (node._state_vars_read + @@ -775,6 +781,7 @@ def _create_patch_enum_uses(slither, result, element): + def _create_patch_struct_uses(slither, result, element): in_file, in_file_str, old_str_of_interest, loc_start, loc_end = _unpack_info(slither, element) @@ -824,5 +831,26 @@ def _create_patch_struct_uses(slither, result, element): # To-do: Check any other place/way where struct type is used (e.g. typecast) + for st in contract.structures: + for elem in st.elems.values(): + if isinstance(elem.type, UserDefinedType): + if isinstance(elem.type.type, Structure): + if str(elem.type.type) == name: + old_str = str(elem.type.type) + new_str = name.capitalize() + + in_file = elem.source_mapping['filename_absolute'] + loc_start = elem.source_mapping['start'] + loc_end = loc_start + len(old_str) + + create_patch(result, + in_file, + loc_start, + loc_end, + old_str, + new_str) + # endregion + + diff --git a/utils/slither_format/utils/usages.py b/utils/slither_format/utils/usages.py new file mode 100644 index 000000000..e69de29bb From 04480e6d38049e38d8c43cae5dc5978475bd6335 Mon Sep 17 00:00:00 2001 From: Josselin Date: Mon, 1 Jul 2019 12:59:59 +0200 Subject: [PATCH 084/223] IR: create ChildExpression, and assign the expression to each IR --- slither/core/children/child_expression.py | 12 ++++ slither/slithir/convert.py | 68 ++++++++++++++++--- slither/slithir/operations/operation.py | 3 +- slither/slithir/operations/phi.py | 6 +- slither/slithir/utils/ssa.py | 2 + .../visitors/slithir/expression_to_slithir.py | 25 ++++++- utils/slither_format/utils/usages.py | 0 7 files changed, 98 insertions(+), 18 deletions(-) delete mode 100644 utils/slither_format/utils/usages.py diff --git a/slither/core/children/child_expression.py b/slither/core/children/child_expression.py index e69de29bb..f918e7a52 100644 --- a/slither/core/children/child_expression.py +++ b/slither/core/children/child_expression.py @@ -0,0 +1,12 @@ + +class ChildExpression: + def __init__(self): + super(ChildExpression, self).__init__() + self._expression = None + + def set_expression(self, expression): + self._expression = expression + + @property + def expression(self): + return self._expression diff --git a/slither/slithir/convert.py b/slither/slithir/convert.py index 63284db77..a41ccd098 100644 --- a/slither/slithir/convert.py +++ b/slither/slithir/convert.py @@ -45,10 +45,14 @@ def convert_expression(expression, node): if isinstance(expression, Literal) and node.type in [NodeType.IF, NodeType.IFLOOP]: cst = Constant(expression.value, expression.type) - result = [Condition(cst)] + cond = Condition(cst) + cond.set_expression(expression) + result = [cond] return result if isinstance(expression, Identifier) and node.type in [NodeType.IF, NodeType.IFLOOP]: - result = [Condition(expression.value)] + cond = Condition(expression.value) + cond.set_expression(expression) + result = [cond] return result @@ -60,11 +64,15 @@ def convert_expression(expression, node): if result: if node.type in [NodeType.IF, NodeType.IFLOOP]: assert isinstance(result[-1], (OperationWithLValue)) - result.append(Condition(result[-1].lvalue)) + cond = Condition(result[-1].lvalue) + cond.set_expression(expression) + result.append(cond) elif node.type == NodeType.RETURN: # May return None if isinstance(result[-1], (OperationWithLValue)): - result.append(Return(result[-1].lvalue)) + r = Return(result[-1].lvalue) + r.set_expression(expression) + result.append(r) return result @@ -326,6 +334,7 @@ def _convert_type_contract(ir, slither): assignment = Assignment(ir.lvalue, Constant(str(bytecode)), ElementaryType('bytes')) + assignment.set_expression(ir.expression) assignment.lvalue.set_type(ElementaryType('bytes')) return assignment if ir.variable_right == 'runtimeCode': @@ -338,12 +347,14 @@ def _convert_type_contract(ir, slither): assignment = Assignment(ir.lvalue, Constant(str(bytecode)), ElementaryType('bytes')) + assignment.set_expression(ir.expression) assignment.lvalue.set_type(ElementaryType('bytes')) return assignment if ir.variable_right == 'name': assignment = Assignment(ir.lvalue, Constant(contract.name), ElementaryType('string')) + assignment.set_expression(ir.expression) assignment.lvalue.set_type(ElementaryType('string')) return assignment @@ -441,14 +452,18 @@ def propagate_types(ir, node): # TODO we should convert the reference to a temporary if the member is a length or a balance if ir.variable_right == 'length' and not isinstance(ir.variable_left, Contract) and isinstance(ir.variable_left.type, (ElementaryType, ArrayType)): length = Length(ir.variable_left, ir.lvalue) + length.set_expression(ir.expression) length.lvalue.points_to = ir.variable_left return length if ir.variable_right == 'balance'and not isinstance(ir.variable_left, Contract) and isinstance(ir.variable_left.type, ElementaryType): - return Balance(ir.variable_left, ir.lvalue) + b = Balance(ir.variable_left, ir.lvalue) + b.set_expression(ir.expression) + return b if ir.variable_right == 'selector' and isinstance(ir.variable_left.type, Function): assignment = Assignment(ir.lvalue, Constant(str(get_function_id(ir.variable_left.type.full_name))), ElementaryType('bytes4')) + assignment.set_expression(ir.expression) assignment.lvalue.set_type(ElementaryType('bytes4')) return assignment if isinstance(ir.variable_left, TemporaryVariable) and isinstance(ir.variable_left.type, TypeInformation): @@ -529,6 +544,7 @@ def extract_tmp_call(ins, contract): if isinstance(ins.called, Variable) and isinstance(ins.called.type, FunctionType): call = InternalDynamicCall(ins.lvalue, ins.called, ins.called.type) + call.set_expression(ins.expression) call.call_id = ins.call_id return call if isinstance(ins.ori, Member): @@ -536,23 +552,28 @@ def extract_tmp_call(ins, contract): if ins.ori.variable_left in contract.inheritance + [contract]: if str(ins.ori.variable_right) in [f.name for f in contract.functions]: internalcall = InternalCall((ins.ori.variable_right, ins.ori.variable_left.name), ins.nbr_arguments, ins.lvalue, ins.type_call) + internalcall.set_expression(ins.expression) internalcall.call_id = ins.call_id return internalcall if str(ins.ori.variable_right) in [f.name for f in contract.events]: eventcall = EventCall(ins.ori.variable_right) + eventcall.set_expression(ins.expression) eventcall.call_id = ins.call_id return eventcall if isinstance(ins.ori.variable_left, Contract): st = ins.ori.variable_left.get_structure_from_name(ins.ori.variable_right) if st: op = NewStructure(st, ins.lvalue) + op.set_expression(ins.expression) op.call_id = ins.call_id return op libcall = LibraryCall(ins.ori.variable_left, ins.ori.variable_right, ins.nbr_arguments, ins.lvalue, ins.type_call) + libcall.set_expression(ins.expression) libcall.call_id = ins.call_id return libcall msgcall = HighLevelCall(ins.ori.variable_left, ins.ori.variable_right, ins.nbr_arguments, ins.lvalue, ins.type_call) msgcall.call_id = ins.call_id + msgcall.set_expression(ins.expression) return msgcall if isinstance(ins.ori, TmpCall): @@ -562,29 +583,42 @@ def extract_tmp_call(ins, contract): if str(ins.called) == 'block.blockhash': ins.called = SolidityFunction('blockhash(uint256)') elif str(ins.called) == 'this.balance': - return SolidityCall(SolidityFunction('this.balance()'), ins.nbr_arguments, ins.lvalue, ins.type_call) + s = SolidityCall(SolidityFunction('this.balance()'), ins.nbr_arguments, ins.lvalue, ins.type_call) + s.set_expression(ins.expression) + return s if isinstance(ins.called, SolidityFunction): - return SolidityCall(ins.called, ins.nbr_arguments, ins.lvalue, ins.type_call) + s = SolidityCall(ins.called, ins.nbr_arguments, ins.lvalue, ins.type_call) + s.set_expression(ins.expression) + return s if isinstance(ins.ori, TmpNewElementaryType): - return NewElementaryType(ins.ori.type, ins.lvalue) + n = NewElementaryType(ins.ori.type, ins.lvalue) + n.set_expression(ins.expression) + return n if isinstance(ins.ori, TmpNewContract): op = NewContract(Constant(ins.ori.contract_name), ins.lvalue) + op.set_expression(ins.expression) op.call_id = ins.call_id return op if isinstance(ins.ori, TmpNewArray): - return NewArray(ins.ori.depth, ins.ori.array_type, ins.lvalue) + n = NewArray(ins.ori.depth, ins.ori.array_type, ins.lvalue) + n.set_expression(ins.expression) + return n if isinstance(ins.called, Structure): op = NewStructure(ins.called, ins.lvalue) + op.set_expression(ins.expression) op.call_id = ins.call_id + op.set_expression(ins.expression) return op if isinstance(ins.called, Event): - return EventCall(ins.called.name) + e = EventCall(ins.called.name) + e.set_expression(ins.expression) + return e raise Exception('Not extracted {} {}'.format(type(ins.called), ins)) @@ -606,11 +640,15 @@ def convert_to_low_level(ir): """ if ir.function_name == 'transfer': assert len(ir.arguments) == 1 + prev_ir = ir ir = Transfer(ir.destination, ir.arguments[0]) + ir.set_expression(prev_ir.expression) return ir elif ir.function_name == 'send': assert len(ir.arguments) == 1 + prev_ir = ir ir = Send(ir.destination, ir.arguments[0], ir.lvalue) + ir.set_expression(prev_ir.expression) ir.lvalue.set_type(ElementaryType('bool')) return ir elif ir.destination.name == 'abi' and ir.function_name in ['encode', @@ -622,6 +660,7 @@ def convert_to_low_level(ir): call = SolidityFunction('abi.{}()'.format(ir.function_name)) new_ir = SolidityCall(call, ir.nbr_arguments, ir.lvalue, ir.type_call) new_ir.arguments = ir.arguments + new_ir.set_expression(ir.expression) if isinstance(call.return_type, list) and len(call.return_type) == 1: new_ir.lvalue.set_type(call.return_type[0]) else: @@ -640,6 +679,7 @@ def convert_to_low_level(ir): new_ir.call_value = ir.call_value new_ir.arguments = ir.arguments new_ir.lvalue.set_type(ElementaryType('bool')) + new_ir.set_expression(ir.expression) return new_ir raise SlithIRError('Incorrect conversion to low level {}'.format(ir)) @@ -662,9 +702,12 @@ def convert_to_push(ir, node): val = TemporaryVariable(node) operation = InitArray(ir.arguments[0], val) + operation.set_expression(ir.expression) ret.append(operation) + prev_ir = ir ir = Push(ir.destination, val) + ir.set_expression(prev_ir.expression) length = Literal(len(operation.init_values), 'uint256') t = operation.init_values[0].type @@ -674,18 +717,22 @@ def convert_to_push(ir, node): if lvalue: length = Length(ir.array, lvalue) + length.set_expression(ir.expression) length.lvalue.points_to = ir.lvalue ret.append(length) return ret + prev_ir = ir ir = Push(ir.destination, ir.arguments[0]) + ir.set_expression(prev_ir.expression) if lvalue: ret = [] ret.append(ir) length = Length(ir.array, lvalue) + length.set_expression(ir.expression) length.lvalue.points_to = ir.lvalue ret.append(length) return ret @@ -701,6 +748,7 @@ def look_for_library(contract, ir, node, using_for, t): ir.nbr_arguments, ir.lvalue, ir.type_call) + lib_call.set_expression(ir.expression) lib_call.call_gas = ir.call_gas lib_call.arguments = [ir.destination] + ir.arguments new_ir = convert_type_library_call(lib_call, lib_contract) diff --git a/slither/slithir/operations/operation.py b/slither/slithir/operations/operation.py index b127bd715..636921fe3 100644 --- a/slither/slithir/operations/operation.py +++ b/slither/slithir/operations/operation.py @@ -1,5 +1,6 @@ import abc from slither.core.context.context import Context +from slither.core.children.child_expression import ChildExpression from slither.core.children.child_node import ChildNode from slither.utils.utils import unroll @@ -21,7 +22,7 @@ class AbstractOperation(abc.ABC): """ pass -class Operation(Context, ChildNode, AbstractOperation): +class Operation(Context, ChildExpression, ChildNode, AbstractOperation): @property def used(self): diff --git a/slither/slithir/operations/phi.py b/slither/slithir/operations/phi.py index a11dfa139..e0d007b0f 100644 --- a/slither/slithir/operations/phi.py +++ b/slither/slithir/operations/phi.py @@ -1,10 +1,6 @@ -import logging from slither.slithir.operations.lvalue import OperationWithLValue -from slither.core.variables.variable import Variable -from slither.slithir.variables import TupleVariable -from slither.core.declarations.function import Function -from slither.slithir.utils.utils import is_valid_lvalue, is_valid_rvalue +from slither.slithir.utils.utils import is_valid_lvalue class Phi(OperationWithLValue): diff --git a/slither/slithir/utils/ssa.py b/slither/slithir/utils/ssa.py index fde9f5eba..4049e5cab 100644 --- a/slither/slithir/utils/ssa.py +++ b/slither/slithir/utils/ssa.py @@ -181,6 +181,8 @@ def generate_ssa_irs(node, local_variables_instances, all_local_variables_instan tuple_variables_instances, all_local_variables_instances) + new_ir.set_expression(ir.expression) + update_lvalue(new_ir, node, local_variables_instances, diff --git a/slither/visitors/slithir/expression_to_slithir.py b/slither/visitors/slithir/expression_to_slithir.py index 7799cf128..5ad663e8c 100644 --- a/slither/visitors/slithir/expression_to_slithir.py +++ b/slither/visitors/slithir/expression_to_slithir.py @@ -83,6 +83,7 @@ class ExpressionToSlithIR(ExpressionVisitor): for idx in range(len(left)): if not left[idx] is None: operation = convert_assignment(left[idx], right[idx], expression.type, expression.expression_return_type) + operation.set_expression(expression) self._result.append(operation) set_val(expression, None) else: @@ -90,6 +91,7 @@ class ExpressionToSlithIR(ExpressionVisitor): for idx in range(len(left)): if not left[idx] is None: operation = Unpack(left[idx], right, idx) + operation.set_expression(expression) self._result.append(operation) set_val(expression, None) else: @@ -97,10 +99,12 @@ class ExpressionToSlithIR(ExpressionVisitor): # uint8[2] var = [1,2]; if isinstance(right, list): operation = InitArray(right, left) + operation.set_expression(expression) self._result.append(operation) set_val(expression, left) else: operation = convert_assignment(left, right, expression.type, expression.expression_return_type) + operation.set_expression(expression) self._result.append(operation) # Return left to handle # a = b = 1; @@ -112,6 +116,7 @@ class ExpressionToSlithIR(ExpressionVisitor): val = TemporaryVariable(self._node) operation = Binary(val, left, right, expression.type) + operation.set_expression(expression) self._result.append(operation) set_val(expression, val) @@ -130,11 +135,10 @@ class ExpressionToSlithIR(ExpressionVisitor): else: val = TemporaryVariable(self._node) internal_call = InternalCall(called, len(args), val, expression.type_call) + internal_call.set_expression(expression) self._result.append(internal_call) set_val(expression, val) else: - val = TemporaryVariable(self._node) - # If tuple if expression.type_call.startswith('tuple(') and expression.type_call != 'tuple()': val = TupleVariable(self._node) @@ -142,6 +146,7 @@ class ExpressionToSlithIR(ExpressionVisitor): val = TemporaryVariable(self._node) message_call = TmpCall(called, len(args), val, expression.type_call) + message_call.set_expression(expression) self._result.append(message_call) set_val(expression, val) @@ -165,8 +170,10 @@ class ExpressionToSlithIR(ExpressionVisitor): init_array_right = left left = init_array_val operation = InitArray(init_array_right, init_array_val) + operation.set_expression(expression) self._result.append(operation) operation = Index(val, left, right, expression.type) + operation.set_expression(expression) self._result.append(operation) set_val(expression, val) @@ -178,18 +185,21 @@ class ExpressionToSlithIR(ExpressionVisitor): expr = get(expression.expression) val = ReferenceVariable(self._node) member = Member(expr, Constant(expression.member_name), val) + member.set_expression(expression) self._result.append(member) set_val(expression, val) def _post_new_array(self, expression): val = TemporaryVariable(self._node) operation = TmpNewArray(expression.depth, expression.array_type, val) + operation.set_expression(expression) self._result.append(operation) set_val(expression, val) def _post_new_contract(self, expression): val = TemporaryVariable(self._node) operation = TmpNewContract(expression.contract_name, val) + operation.set_expression(expression) self._result.append(operation) set_val(expression, val) @@ -197,6 +207,7 @@ class ExpressionToSlithIR(ExpressionVisitor): # TODO unclear if this is ever used? val = TemporaryVariable(self._node) operation = TmpNewElementaryType(expression.type, val) + operation.set_expression(expression) self._result.append(operation) set_val(expression, val) @@ -212,6 +223,7 @@ class ExpressionToSlithIR(ExpressionVisitor): expr = get(expression.expression) val = TemporaryVariable(self._node) operation = TypeConversion(val, expr, expression.type) + operation.set_expression(expression) self._result.append(operation) set_val(expression, val) @@ -220,32 +232,40 @@ class ExpressionToSlithIR(ExpressionVisitor): if expression.type in [UnaryOperationType.BANG, UnaryOperationType.TILD]: lvalue = TemporaryVariable(self._node) operation = Unary(lvalue, value, expression.type) + operation.set_expression(expression) self._result.append(operation) set_val(expression, lvalue) elif expression.type in [UnaryOperationType.DELETE]: operation = Delete(value, value) + operation.set_expression(expression) self._result.append(operation) set_val(expression, value) elif expression.type in [UnaryOperationType.PLUSPLUS_PRE]: operation = Binary(value, value, Constant("1"), BinaryType.ADDITION) + operation.set_expression(expression) self._result.append(operation) set_val(expression, value) elif expression.type in [UnaryOperationType.MINUSMINUS_PRE]: operation = Binary(value, value, Constant("1"), BinaryType.SUBTRACTION) + operation.set_expression(expression) self._result.append(operation) set_val(expression, value) elif expression.type in [UnaryOperationType.PLUSPLUS_POST]: lvalue = TemporaryVariable(self._node) operation = Assignment(lvalue, value, value.type) + operation.set_expression(expression) self._result.append(operation) operation = Binary(value, value, Constant("1"), BinaryType.ADDITION) + operation.set_expression(expression) self._result.append(operation) set_val(expression, lvalue) elif expression.type in [UnaryOperationType.MINUSMINUS_POST]: lvalue = TemporaryVariable(self._node) operation = Assignment(lvalue, value, value.type) + operation.set_expression(expression) self._result.append(operation) operation = Binary(value, value, Constant("1"), BinaryType.SUBTRACTION) + operation.set_expression(expression) self._result.append(operation) set_val(expression, lvalue) elif expression.type in [UnaryOperationType.PLUS_PRE]: @@ -253,6 +273,7 @@ class ExpressionToSlithIR(ExpressionVisitor): elif expression.type in [UnaryOperationType.MINUS_PRE]: lvalue = TemporaryVariable(self._node) operation = Binary(lvalue, Constant("0"), value, BinaryType.SUBTRACTION) + operation.set_expression(expression) self._result.append(operation) set_val(expression, lvalue) else: diff --git a/utils/slither_format/utils/usages.py b/utils/slither_format/utils/usages.py deleted file mode 100644 index e69de29bb..000000000 From 03726f6fc33525382f472bae846969d314317638 Mon Sep 17 00:00:00 2001 From: Josselin Date: Mon, 1 Jul 2019 18:20:32 +0200 Subject: [PATCH 085/223] WIP refactor naming convention --- .../formatters/naming_convention.py | 152 +++++++++++++++++- 1 file changed, 149 insertions(+), 3 deletions(-) diff --git a/utils/slither_format/formatters/naming_convention.py b/utils/slither_format/formatters/naming_convention.py index 307613b78..14fcccb4f 100644 --- a/utils/slither_format/formatters/naming_convention.py +++ b/utils/slither_format/formatters/naming_convention.py @@ -1,11 +1,11 @@ import re import logging from slither.core.expressions.identifier import Identifier -from slither.core.declarations import Structure -from slither.core.solidity_types import UserDefinedType from slither.slithir.operations import NewContract from slither.slithir.operations import Member from slither.visitors.expression.read_var_syntactic import ReadVarSyntactic +from slither.core.solidity_types import UserDefinedType, MappingType +from slither.core.declarations import Enum, Contract, Structure from ..exceptions import FormatError from ..utils.patches import create_patch @@ -354,7 +354,152 @@ def _create_patch_parameter_declaration(slither, result, element): ################################################################################### ################################################################################### -def _create_patch_contract_uses(slither, result, element): +# group 1: beginning of the from type +# group 2: beginning of the to type +# nested mapping are within the group 1 +RE_MAPPING = '[ ]*mapping[ ]*\([ ]*([\=\>\(\) a-zA-Z0-9\._\[\]]*)[ ]*=>[ ]*([a-zA-Z0-9\._\[\]]*)\)' + +def _explore_types(slither, result, target, convert, type, filename_source_code, start, end): + if isinstance(type, UserDefinedType): + # Patch type based on contract/enum + if isinstance(type.type, (Enum, Contract)): + if type.type == target: + old_str = type.type.name + new_str = convert(old_str) + + loc_start = start + loc_end = loc_start + len(old_str) + + create_patch(result, + filename_source_code, + loc_start, + loc_end, + old_str, + new_str) + + + else: + # Patch type based on structure + assert isinstance(type.type, Structure) + if type.type == target: + old_str = type.type.name + new_str = convert(old_str) + + loc_start = start + loc_end = loc_start + len(old_str) + + create_patch(result, + filename_source_code, + loc_start, + loc_end, + old_str, + new_str) + + # Structure contain a list of elements, that might need patching + # .elems return a list of VariableStructure + _explore_variables_declaration(slither, + type.type.elems.values(), + result, + target, + convert) + + if isinstance(type, MappingType): + # Mapping has three steps: + # Convertir the "from" type + # Convertir the "to" type + # Convertir nested type in the "from" + # Ex: mapping (mapping (badName => uint) => uint) + + # Do the comparison twice, so we can factor together the re matching + if isinstance(type.type_from, UserDefinedType) or target in [type.type_from, type.type_to]: + + old_str = type.type.name + new_str = convert(old_str) + + full_txt_start = start + full_txt_end = end + full_txt = slither.source_code[filename_source_code][full_txt_start:full_txt_end] + re_match = re.match(RE_MAPPING, full_txt) + + if type.type_from == target: + + loc_start = start + re_match.start(1) + loc_end = loc_start + len(old_str) + + create_patch(result, + filename_source_code, + loc_start, + loc_end, + old_str, + new_str) + + if type.type_to == target: + + loc_start = start + re_match.start(2) + loc_end = loc_start + len(old_str) + + create_patch(result, + filename_source_code, + loc_start, + loc_end, + old_str, + new_str) + + if isinstance(type.type_from, UserDefinedType): + loc_start = start + re_match.start(1) + loc_end = start + re_match.start(2) + _explore_types(slither, result, target, convert, type, filename_source_code, loc_start, loc_end) + + + +def _explore_variables_declaration(slither, variables, result, target, convert): + for variable in variables: + filename_source_code = variable.source_code['filename_absolute'] + full_txt_start = variable.source_code['start'] + full_txt_end = full_txt_start + variable.source_code['length'] + full_txt = slither.source_code[filename_source_code][full_txt_start:full_txt_end] + + _explore_types(slither, + result, + target, + convert, + variable.type, + filename_source_code, + full_txt_start, + variable.source_code['start'] + variable.source_code['length']) + + + if variable == target: + old_str = variable.name + new_str = convert(old_str) + + # The name is after the space + matches = re.finditer('[ ]*', full_txt) + # Look for the end offset of the largest list of ' ' + loc_start = max(matches, key=lambda x:len(x.group())).end() - 1 + loc_end = loc_start + len(old_str) + + create_patch(result, + filename_source_code, + loc_start, + loc_end, + old_str, + new_str) + + +def _explore_contract_declaration(slither, result, target, convert): + for contract in slither.derived_contracts: + _explore_variables_declaration(slither, contract.state_variable, result, target, convert) + for st in contract.structures: + _explore_variables_declaration(slither, st.elem.values(), result, target, convert) + + +def _convert_capitalize_contract(name): + return name.capitalize() + + + +def _create_patch_contract_uses_old(slither, result, element): in_file, in_file_str, old_str_of_interest, loc_start, loc_end = _unpack_info(slither, element) name = get_name(element) @@ -367,6 +512,7 @@ def _create_patch_contract_uses(slither, result, element): # To-do: Deep-check aggregate types (struct and mapping) svs = target_contract.variables for sv in svs: + print(sv.type) if (str(sv.type) == name): old_str_of_interest = in_file_str[sv.source_mapping['start']:(sv.source_mapping['start'] + sv.source_mapping['length'])] From 4cbe048ce71850c793006fc7858f287829b51b5a Mon Sep 17 00:00:00 2001 From: Josselin Date: Wed, 3 Jul 2019 10:36:52 +0200 Subject: [PATCH 086/223] Fix incorrect arguments to crytic-compile (fix #289) --- slither/__main__.py | 49 +++-------------------------------- slither/utils/command_line.py | 40 ++++++++++++++++++++++++++++ 2 files changed, 44 insertions(+), 45 deletions(-) diff --git a/slither/__main__.py b/slither/__main__.py index a1b4ce4ad..2274ff123 100644 --- a/slither/__main__.py +++ b/slither/__main__.py @@ -22,7 +22,8 @@ from slither.slither import Slither from slither.utils.colors import red, yellow, set_colorization_enabled from slither.utils.command_line import (output_detectors, output_results_to_markdown, output_detectors_json, output_printers, - output_to_markdown, output_wiki) + output_to_markdown, output_wiki, defaults_flag_in_config, + read_config_file) from crytic_compile import is_supported from slither.exceptions import SlitherException @@ -84,12 +85,8 @@ def process_files(filenames, args, detector_classes, printer_classes): all_contracts.append(contract_loaded['ast']) slither = Slither(all_contracts, - solc=args.solc, - disable_solc_warnings=args.disable_solc_warnings, - solc_arguments=args.solc_args, filter_paths=parse_filter_paths(args), - triage_mode=args.triage_mode, - exclude_dependencies=args.exclude_dependencies) + **vars(args)) return _process(slither, detector_classes, printer_classes) @@ -254,32 +251,6 @@ def parse_filter_paths(args): return args.filter_paths.split(',') return [] -# Those are the flags shared by the command line and the config file -defaults_flag_in_config = { - 'detectors_to_run': 'all', - 'printers_to_run': None, - 'detectors_to_exclude': None, - 'exclude_dependencies': False, - 'exclude_informational': False, - 'exclude_low': False, - 'exclude_medium': False, - 'exclude_high': False, - 'solc': 'solc', - 'solc_args': None, - 'disable_solc_warnings': False, - 'json': None, - 'truffle_version': None, - 'disable_color': False, - 'filter_paths': None, - 'truffle_ignore_compile': False, - 'truffle_build_directory': 'build/contracts', - 'embark_ignore_compile': False, - 'embark_overwrite_config': False, - # debug command - 'legacy_ast': False, - 'ignore_return_value': False - } - def parse_args(detector_classes, printer_classes): parser = argparse.ArgumentParser(description='Slither. For usage information, see https://github.com/crytic/slither/wiki/Usage', usage="slither.py contract.sol [flag]") @@ -441,19 +412,7 @@ def parse_args(detector_classes, printer_classes): sys.exit(1) args = parser.parse_args() - - if os.path.isfile(args.config_file): - try: - with open(args.config_file) as f: - config = json.load(f) - for key, elem in config.items(): - if key not in defaults_flag_in_config: - logger.info(yellow('{} has an unknown key: {} : {}'.format(args.config_file, key, elem))) - continue - if getattr(args, key) == defaults_flag_in_config[key]: - setattr(args, key, elem) - except json.decoder.JSONDecodeError as e: - logger.error(red('Impossible to read {}, please check the file {}'.format(args.config_file, e))) + read_config_file(args) return args diff --git a/slither/utils/command_line.py b/slither/utils/command_line.py index d1a495a23..c69609f35 100644 --- a/slither/utils/command_line.py +++ b/slither/utils/command_line.py @@ -1,8 +1,48 @@ +import os +import logging import json from collections import defaultdict from prettytable import PrettyTable +from crytic_compile.cryticparser.defaults import defaults_flag_in_config as defaults_flag_in_config_crytic_compile from slither.detectors.abstract_detector import classification_txt +from .colors import yellow, red + +logger = logging.getLogger("Slither") + +# Those are the flags shared by the command line and the config file +defaults_flag_in_config = { + 'detectors_to_run': 'all', + 'printers_to_run': None, + 'detectors_to_exclude': None, + 'exclude_dependencies': False, + 'exclude_informational': False, + 'exclude_low': False, + 'exclude_medium': False, + 'exclude_high': False, + 'json': None, + 'disable_color': False, + 'filter_paths': None, + # debug command + 'legacy_ast': False, + 'ignore_return_value': False, + **defaults_flag_in_config_crytic_compile + } + +def read_config_file(args): + if os.path.isfile(args.config_file): + try: + with open(args.config_file) as f: + config = json.load(f) + for key, elem in config.items(): + if key not in defaults_flag_in_config: + logger.info(yellow('{} has an unknown key: {} : {}'.format(args.config_file, key, elem))) + continue + if getattr(args, key) == defaults_flag_in_config[key]: + setattr(args, key, elem) + except json.decoder.JSONDecodeError as e: + logger.error(red('Impossible to read {}, please check the file {}'.format(args.config_file, e))) + def output_to_markdown(detector_classes, printer_classes, filter_wiki): From 84f3573c74ff8dc16c06ede51c2c06375e8afd76 Mon Sep 17 00:00:00 2001 From: Josselin Date: Wed, 3 Jul 2019 10:41:49 +0200 Subject: [PATCH 087/223] Improve logging of parsing issues --- slither/__main__.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/slither/__main__.py b/slither/__main__.py index 2274ff123..ee664653d 100644 --- a/slither/__main__.py +++ b/slither/__main__.py @@ -485,6 +485,8 @@ def main_impl(all_detector_classes, all_printer_classes): :param all_detector_classes: A list of all detectors that can be included/excluded. :param all_printer_classes: A list of all printers that can be included. """ + # Set logger of Slither to info, to catch warnings related to the arg parsing + logger.setLevel(logging.INFO) args = parse_args(all_detector_classes, all_printer_classes) # Set colorization option From 528cae028abafd7ba6fa0e6b871092e13ef73330 Mon Sep 17 00:00:00 2001 From: Josselin Date: Wed, 3 Jul 2019 11:06:35 +0200 Subject: [PATCH 088/223] Minor --- slither/utils/command_line.py | 42 ------------------- .../formatters/naming_convention.py | 14 ++++--- 2 files changed, 8 insertions(+), 48 deletions(-) diff --git a/slither/utils/command_line.py b/slither/utils/command_line.py index f69946db5..be1c566d1 100644 --- a/slither/utils/command_line.py +++ b/slither/utils/command_line.py @@ -47,48 +47,6 @@ def read_config_file(args): logger.error(red('Impossible to read {}, please check the file {}'.format(args.config_file, e))) -logger = logging.getLogger("Slither") - -# Those are the flags shared by the command line and the config file -defaults_flag_in_config = { - 'detectors_to_run': 'all', - 'printers_to_run': None, - 'detectors_to_exclude': None, - 'exclude_informational': False, - 'exclude_low': False, - 'exclude_medium': False, - 'exclude_high': False, - 'solc': 'solc', - 'solc_args': None, - 'disable_solc_warnings': False, - 'json': None, - 'truffle_version': None, - 'disable_color': False, - 'filter_paths': None, - 'truffle_ignore_compile': False, - 'truffle_build_directory': 'build/contracts', - 'embark_ignore_compile': False, - 'embark_overwrite_config': False, - # debug command - 'legacy_ast': False, - 'ignore_return_value': False - } - -def read_config_file(args): - if os.path.isfile(args.config_file): - try: - with open(args.config_file) as f: - config = json.load(f) - for key, elem in config.items(): - if key not in defaults_flag_in_config: - logger.info(yellow('{} has an unknown key: {} : {}'.format(args.config_file, key, elem))) - continue - if getattr(args, key) == defaults_flag_in_config[key]: - setattr(args, key, elem) - except json.decoder.JSONDecodeError as e: - logger.error(red('Impossible to read {}, please check the file {}'.format(args.config_file, e))) - - def output_to_markdown(detector_classes, printer_classes, filter_wiki): def extract_help(cls): diff --git a/utils/slither_format/formatters/naming_convention.py b/utils/slither_format/formatters/naming_convention.py index 14fcccb4f..2eeae27ff 100644 --- a/utils/slither_format/formatters/naming_convention.py +++ b/utils/slither_format/formatters/naming_convention.py @@ -405,23 +405,22 @@ def _explore_types(slither, result, target, convert, type, filename_source_code, if isinstance(type, MappingType): # Mapping has three steps: - # Convertir the "from" type - # Convertir the "to" type - # Convertir nested type in the "from" + # Convert the "from" type + # Convert the "to" type + # Convert nested type in the "from" # Ex: mapping (mapping (badName => uint) => uint) # Do the comparison twice, so we can factor together the re matching if isinstance(type.type_from, UserDefinedType) or target in [type.type_from, type.type_to]: - old_str = type.type.name - new_str = convert(old_str) - full_txt_start = start full_txt_end = end full_txt = slither.source_code[filename_source_code][full_txt_start:full_txt_end] re_match = re.match(RE_MAPPING, full_txt) if type.type_from == target: + old_str = type.type_from.name + new_str = convert(old_str) loc_start = start + re_match.start(1) loc_end = loc_start + len(old_str) @@ -435,6 +434,9 @@ def _explore_types(slither, result, target, convert, type, filename_source_code, if type.type_to == target: + old_str = type.type_to.name + new_str = convert(old_str) + loc_start = start + re_match.start(2) loc_end = loc_start + len(old_str) From d625fa0b78a97c02229159fd2f45af248ed00020 Mon Sep 17 00:00:00 2001 From: Josselin Date: Wed, 3 Jul 2019 15:27:52 +0200 Subject: [PATCH 089/223] slither-format: Rewrite naming convetion with a modular approach --- .../formatters/naming_convention.py | 1078 +++++------------ 1 file changed, 299 insertions(+), 779 deletions(-) diff --git a/utils/slither_format/formatters/naming_convention.py b/utils/slither_format/formatters/naming_convention.py index 2eeae27ff..19c248b0e 100644 --- a/utils/slither_format/formatters/naming_convention.py +++ b/utils/slither_format/formatters/naming_convention.py @@ -2,7 +2,8 @@ import re import logging from slither.core.expressions.identifier import Identifier from slither.slithir.operations import NewContract -from slither.slithir.operations import Member +from slither.slithir.operations import Member, Send, Transfer, OperationWithLValue, HighLevelCall, LowLevelCall, \ + InternalCall, InternalDynamicCall from slither.visitors.expression.read_var_syntactic import ReadVarSyntactic from slither.core.solidity_types import UserDefinedType, MappingType from slither.core.declarations import Enum, Contract, Structure @@ -26,6 +27,43 @@ def format(slither, result): _patch(slither, result, element, target) +# endregion +################################################################################### +################################################################################### +# region Conventions +################################################################################### +################################################################################### + +def _convert_CapWords(name): + name = name.capitalize() + + while '_' in name: + offset = name.find('_') + if len(name) > offset: + name = name[0:offset] + name[offset+1].upper() + name[offset+1:] + + return name + +def _convert_mixedCase(name): + + while '_' in name: + offset = name.find('_') + if len(name) > offset: + name = name[0:offset] + name[offset + 1].upper() + name[offset + 2:] + + name = name[0].lower() + name[1:] + return name + +def _convert_UPPER_CASE_WITH_UNDERSCORES(name): + return name.upper() + +conventions ={ + "CapWords":_convert_CapWords, + "mixedCase":_convert_mixedCase, + "UPPER_CASE_WITH_UNDERSCORES":_convert_UPPER_CASE_WITH_UNDERSCORES +} + + # endregion ################################################################################### ################################################################################### @@ -66,300 +104,83 @@ def get_contract_name(element): def _patch(slither, result, element, _target): if _target == "contract": - _create_patch_contract_definition(slither, result, element) - _create_patch_contract_uses(slither, result, element) + target = slither.get_contract_from_name(element['name']) elif _target == "structure": - _create_patch_struct_definition(slither, result, element) - _create_patch_struct_uses(slither, result, element) + target = slither.get_structure_from_name(element['name']) elif _target == "event": - _create_patch_event_definition(slither, result, element) - _create_patch_event_calls(slither, result, element) + target = slither.get_event_from_name(element['name']) elif _target == "function": # Avoid constructor (FP?) if element['name'] != element['type_specific_fields']['parent']['name']: - _create_patch_function_definition(slither, result, element) - _create_patch_function_calls(slither, result, element) - - elif _target == "parameter": - _create_patch_parameter_declaration(slither, result, element) - _create_patch_parameter_uses(slither, result, element) + contract_name = element['type_specific_fields']['parent']['name'] + function_sig = element['type_specific_fields']['signature'] + contract = slither.get_contract_from_name(contract_name) + target = contract.get_function_from_signature(function_sig) - elif _target == "variable": - _create_patch_state_variable_declaration(slither, result, element) - _create_patch_state_variable_uses(slither, result, element) + elif _target == "modifier": + contract_name = element['type_specific_fields']['parent']['name'] + modifier_sig = element['type_specific_fields']['signature'] + contract = slither.get_contract_from_name(contract_name) + target = contract.get_modifier_from_signature(modifier_sig) - elif _target == "variable_constant": - _create_patch_state_variable_constant_declaration(slither, result, element) - _create_patch_state_variable_uses(slither, result, element) + elif _target == "parameter": + contract_name = element['type_specific_fields']['parent']['type_specific_fields']['parent']['name'] + function_sig = element['type_specific_fields']['parent']['signature'] + param_name = element['name'] + contract = slither.get_contract_from_name(contract_name) + function = contract.get_function_from_signature(function_sig) + target = function.get_local_variable_from_name(param_name) + + elif _target in ["variable", "variable_constant"]: + # Local variable + if element['type_specific_fields']['parent'] == 'function': + contract_name = element['type_specific_fields']['parent']['type_specific_fields']['parent']['name'] + function_sig = element['type_specific_fields']['parent']['signature'] + var_name = element['name'] + contract = slither.get_contract_from_name(contract_name) + function = contract.get_function_from_signature(function_sig) + target = function.get_local_variable_from_name(var_name) + # State variable + else: + contract_name = element['type_specific_fields']['parent']['name'] + var_name = element['type_specific_fields']['name'] + contract = slither.get_contract_from_name(contract_name) + target = contract.get_state_variable_from_name(var_name) elif _target == "enum": - _create_patch_enum_declaration(slither, result, element) - _create_patch_enum_uses(slither, result, element) - - elif _target == "modifier": - _create_patch_modifier_definition(slither, result, element) - _create_patch_modifier_uses(slither, result, element) + contract_name = element['type_specific_fields']['parent']['name'] + enum_name = element['type_specific_fields']['name'] + contract = slither.get_contract_from_name(contract_name) + target = contract.get_enum_from_canonical_name(enum_name) else: raise FormatError("Unknown naming convention! " + _target) -# endregion -################################################################################### -################################################################################### -# region Declaration and Definition -################################################################################### -################################################################################### - - -def _create_patch_contract_definition(slither, result, element): - in_file, in_file_str, old_str_of_interest, loc_start, loc_end = _unpack_info(slither, element) - - name = get_name(element) - - # Locate the name following keywords `contract` | `interface` | `library` - m = re.match(r'(.*)' + "(contract|interface|library)" + r'(.*)' + name, old_str_of_interest.decode('utf-8')) - - old_str_of_interest = in_file_str[loc_start:loc_start+m.span()[1]] - # Capitalize the name - (new_string, num_repl) = re.subn(r'(.*)' + r'(contract|interface|library)' + r'(.*)' + name, - r'\1' + r'\2' + r'\3' + name.capitalize(), - old_str_of_interest.decode('utf-8'), 1) - - if num_repl == 0: - raise FormatError(f"Could not find contract: {name}") - - old_string = old_str_of_interest.decode('utf-8') - - loc_end = loc_start + m.span()[1] - - create_patch(result, - in_file, - loc_start, - loc_end, - old_string, - new_string) - - -def _create_patch_state_variable_declaration(slither, result, element): - in_file, in_file_str, old_str_of_interest, loc_start, loc_end = _unpack_info(slither, element) - - name = get_name(element) - - m = re.search(name, old_str_of_interest.decode('utf-8')) - # Skip rare cases where re search fails. To-do: Investigate - if not m: - return None - new_string = old_str_of_interest.decode('utf-8')[m.span()[0]:m.span()[1]] - new_string = new_string[0].lower() + new_string[1:] - - old_string = old_str_of_interest.decode('utf-8')[m.span()[0]:m.span()[1]] - - loc_end = loc_start + m.span()[1] - loc_start = loc_start + m.span()[0] - - create_patch(result, - in_file, - loc_start, - loc_end, - old_string, - new_string) + _explore(slither, + result, + target, + conventions[element['additional_fields']['convention']]) -def _create_patch_state_variable_constant_declaration(slither, result, element): - in_file, in_file_str, old_str_of_interest, loc_start, _ = _unpack_info(slither, element) - - name = get_name(element) - - m = re.search(name, old_str_of_interest.decode('utf-8')) - # Skip rare cases where re search fails. To-do: Investigate - if not m: - return None - # Convert constant state variables to upper case - new_string = old_str_of_interest.decode('utf-8')[m.span()[0]:m.span()[1]].upper() - - old_string = old_str_of_interest.decode('utf-8')[m.span()[0]:m.span()[1]] - loc_end = loc_start + m.span()[1] - loc_start = loc_start + m.span()[0] - - create_patch(result, - in_file, - loc_start, - loc_end, - old_string, - new_string) - - -def _create_patch_enum_declaration(slither, result, element): - in_file, in_file_str, old_str_of_interest, loc_start, loc_end = _unpack_info(slither, element) - - name = get_name(element) - - m = re.search(name, old_str_of_interest.decode('utf-8')) - # Skip rare cases where re search fails. To-do: Investigate - if not m: - return None - # Search for the enum name after the `enum` keyword - # Capitalize enum name - (new_string, num_repl) = re.subn(r'(.*)' + "enum" + r'(.*)' + name, r'\1' + "enum" + r'\2' + - name[0].capitalize() + name[1:], - old_str_of_interest.decode('utf-8'), 1) - - if num_repl == 0: - raise FormatError(f"Could not find enum: {name}") - - old_string = old_str_of_interest.decode('utf-8') - - create_patch(result, - in_file, - loc_start, - loc_end, - old_string, - new_string) - - -def _create_patch_struct_definition(slither, result, element): - in_file, in_file_str, old_str_of_interest, loc_start, loc_end = _unpack_info(slither, element) - - name = get_name(element) - - m = re.search(name, old_str_of_interest.decode('utf-8')) - # Skip rare cases where re search fails. To-do: Investigate - if not m: - return None - # Capitalize the struct name beyond the keyword `struct` - - (new_string, num_repl) = re.subn(r'(.*)'+"struct"+r'(.*)'+name, r'\1'+"struct"+r'\2'+ - name.capitalize(), - old_str_of_interest.decode('utf-8'), 1) - - if num_repl == 0: - raise FormatError(f"Could not find struct: {name}") - - old_string = old_str_of_interest.decode('utf-8') - - create_patch(result, - in_file, - loc_start, - loc_end, - old_string, - new_string) - - -def _create_patch_modifier_definition(slither, result, element): - in_file, in_file_str, old_str_of_interest, loc_start, loc_end = _unpack_info(slither, element) - name = get_name(element) - - in_file_str = slither.source_code[in_file].encode('utf-8') - old_str_of_interest = in_file_str[loc_start:loc_end] - # Search for the modifier name after the `modifier` keyword - m = re.match(r'(.*)'+"modifier"+r'(.*)'+name, old_str_of_interest.decode('utf-8')) - old_str_of_interest = in_file_str[loc_start:loc_end+m.span()[1]] - # Change the first letter of the modifier name to lowercase - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"modifier"+r'(.*)'+name, r'\1'+"modifier"+r'\2' + - name[0].lower()+name[1:], old_str_of_interest.decode('utf-8'), 1) - if num_repl != 0: - create_patch(result, - in_file, - loc_start, - loc_end + m.span()[1], - old_str_of_interest.decode('utf-8'), - new_str_of_interest) - else: - raise FormatError(f"Could not find modifier {name}") - - -def _create_patch_function_definition(slither, result, element): - in_file, in_file_str, old_str_of_interest, loc_start, loc_end = _unpack_info(slither, element) - name = get_name(element) - - in_file_str = slither.source_code[in_file].encode('utf-8') - old_str_of_interest = in_file_str[loc_start:loc_end] - # Search for the function name after the `function` keyword - m = re.match(r'(.*)'+"function"+r'\s*'+name, old_str_of_interest.decode('utf-8')) - old_str_of_interest = in_file_str[loc_start:loc_start+m.span()[1]] - # Change the first letter of the function name to lowercase - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"function"+r'(.*)'+name, r'\1'+"function"+r'\2'+ - name[0].lower()+name[1:], old_str_of_interest.decode('utf-8'), 1) - if num_repl != 0: - create_patch(result, - in_file, - loc_start, - loc_start+m.span()[1], - old_str_of_interest.decode('utf-8'), - new_str_of_interest) - - else: - raise FormatError(f"Could not find function {name}") - -def _create_patch_event_definition(slither, result, element): - in_file, in_file_str, old_str_of_interest, loc_start, loc_end = _unpack_info(slither, element) - - name = get_name(element) - contract_name = get_contract_name(element) - - target_contract = slither.get_contract_from_name(contract_name) - if not target_contract: - raise FormatError(f"Contract not found {contract_name}") - for event in target_contract.events: - if event.name == name: - # Get only event name without parameters - event_name = name.split('(')[0] - f_event = event.source_mapping['filename_absolute'] - in_file_str = slither.source_code[f_event].encode('utf-8') - old_str_of_interest = in_file_str[loc_start:loc_end] - # Capitalize event name - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+"event"+r'(.*)'+event_name, r'\1'+"event"+r'\2' + - event_name.capitalize(), - old_str_of_interest.decode('utf-8'), 1) - if num_repl != 0: - create_patch(result, - f_event, - loc_start, - loc_end, - old_str_of_interest.decode('utf-8'), - new_str_of_interest) - else: - raise FormatError(f"Could not find event {name}") - -def _create_patch_parameter_declaration(slither, result, element): - in_file, in_file_str, old_str_of_interest, loc_start, loc_end = _unpack_info(slither, element) - name = get_name(element) - - # To-do: Change format logic below - how do we convert a name to mixedCase? - if(name[0] == '_'): - # If parameter name begins with underscore, capitalize the letter after underscore - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+name[0]+name[1].upper() + - name[2:]+r'\2', old_str_of_interest.decode('utf-8'), 1) - else: - # Add underscore and capitalize the first letter - (new_str_of_interest, num_repl) = re.subn(r'(.*)' + name + r'(.*)', r'\1' + '_' + name.capitalize() + - r'\2', old_str_of_interest.decode('utf-8'), 1) - if num_repl != 0: - create_patch(result, - in_file, - loc_start, - loc_end, - old_str_of_interest.decode('utf-8'), - new_str_of_interest) - else: - raise FormatError(f"Could not find parameter declaration {name}") - # endregion ################################################################################### ################################################################################### -# region Usage patches +# region Explore functions ################################################################################### ################################################################################### # group 1: beginning of the from type # group 2: beginning of the to type # nested mapping are within the group 1 -RE_MAPPING = '[ ]*mapping[ ]*\([ ]*([\=\>\(\) a-zA-Z0-9\._\[\]]*)[ ]*=>[ ]*([a-zA-Z0-9\._\[\]]*)\)' +#RE_MAPPING = '[ ]*mapping[ ]*\([ ]*([\=\>\(\) a-zA-Z0-9\._\[\]]*)[ ]*=>[ ]*([a-zA-Z0-9\._\[\]]*)\)' +RE_MAPPING_FROM = '([a-zA-Z0-9\._\[\]]*)' +RE_MAPPING_TO = '([\=\>\(\) a-zA-Z0-9\._\[\]\ ]*)' +RE_MAPPING = '[ ]*mapping[ ]*\([ ]*' + RE_MAPPING_FROM + '[ ]*' + '=>' + '[ ]*'+ RE_MAPPING_TO + '\)' -def _explore_types(slither, result, target, convert, type, filename_source_code, start, end): +def _explore_type(slither, result, target, convert, type, filename_source_code, start, end): if isinstance(type, UserDefinedType): # Patch type based on contract/enum if isinstance(type.type, (Enum, Contract)): @@ -407,16 +228,18 @@ def _explore_types(slither, result, target, convert, type, filename_source_code, # Mapping has three steps: # Convert the "from" type # Convert the "to" type - # Convert nested type in the "from" + # Convert nested type in the "to" # Ex: mapping (mapping (badName => uint) => uint) # Do the comparison twice, so we can factor together the re matching - if isinstance(type.type_from, UserDefinedType) or target in [type.type_from, type.type_to]: + # mapping can only have elementary type in type_from + if isinstance(type.type_to, (UserDefinedType, MappingType)) or target in [type.type_from, type.type_to]: full_txt_start = start full_txt_end = end full_txt = slither.source_code[filename_source_code][full_txt_start:full_txt_end] re_match = re.match(RE_MAPPING, full_txt) + assert re_match if type.type_from == target: old_str = type.type_from.name @@ -447,38 +270,49 @@ def _explore_types(slither, result, target, convert, type, filename_source_code, old_str, new_str) - if isinstance(type.type_from, UserDefinedType): - loc_start = start + re_match.start(1) - loc_end = start + re_match.start(2) - _explore_types(slither, result, target, convert, type, filename_source_code, loc_start, loc_end) + if isinstance(type.type_to, (UserDefinedType, MappingType)): + loc_start = start + re_match.start(2) + loc_end = start + re_match.end(2) + _explore_type(slither, + result, + target, + convert, + type.type_to, + filename_source_code, + loc_start, + loc_end) def _explore_variables_declaration(slither, variables, result, target, convert): for variable in variables: - filename_source_code = variable.source_code['filename_absolute'] - full_txt_start = variable.source_code['start'] - full_txt_end = full_txt_start + variable.source_code['length'] + # First explore the type of the variable + filename_source_code = variable.source_mapping['filename_absolute'] + full_txt_start = variable.source_mapping['start'] + full_txt_end = full_txt_start + variable.source_mapping['length'] full_txt = slither.source_code[filename_source_code][full_txt_start:full_txt_end] - _explore_types(slither, - result, - target, - convert, - variable.type, - filename_source_code, - full_txt_start, - variable.source_code['start'] + variable.source_code['length']) - + _explore_type(slither, + result, + target, + convert, + variable.type, + filename_source_code, + full_txt_start, + variable.source_mapping['start'] + variable.source_mapping['length']) + # If the variable is the target if variable == target: old_str = variable.name new_str = convert(old_str) # The name is after the space + # We take all the space, as we dont know the type + # In comparison to other matches, it is ok as there will not be more than one + # 'spaces' zone (ex: for function, the body and the signature will also contain space) matches = re.finditer('[ ]*', full_txt) # Look for the end offset of the largest list of ' ' - loc_start = max(matches, key=lambda x:len(x.group())).end() - 1 + loc_start = full_txt_start + max(matches, key=lambda x:len(x.group())).end() loc_end = loc_start + len(old_str) create_patch(result, @@ -489,514 +323,200 @@ def _explore_variables_declaration(slither, variables, result, target, convert): new_str) -def _explore_contract_declaration(slither, result, target, convert): - for contract in slither.derived_contracts: - _explore_variables_declaration(slither, contract.state_variable, result, target, convert) - for st in contract.structures: - _explore_variables_declaration(slither, st.elem.values(), result, target, convert) +def _explore_modifiers_calls(slither, function, result, target, convert): + pass + #for modifier in function._expression_modifiers: + # print(type(modifier)) -def _convert_capitalize_contract(name): - return name.capitalize() +def _explore_structures_declaration(slither, structures, result, target, convert): + for st in structures: + # Explore the variable declared within the structure (VariableStructure) + _explore_variables_declaration(slither, st.elem.values(), result, target, convert) + # If the structure is the target + if st == target: + old_str = st.name + new_str = convert(old_str) + filename_source_code = st.source_mapping['filename_absolute'] + full_txt_start = st.source_mapping['start'] + full_txt_end = full_txt_start + st.source_mapping['length'] + full_txt = slither.source_code[filename_source_code][full_txt_start:full_txt_end] + + # The name is after the space + matches = re.finditer('[struct][ ]*', full_txt) + # Look for the end offset of the largest list of ' ' + loc_start = full_txt_start + max(matches, key=lambda x: len(x.group())).end() + loc_end = loc_start + len(old_str) -def _create_patch_contract_uses_old(slither, result, element): - in_file, in_file_str, old_str_of_interest, loc_start, loc_end = _unpack_info(slither, element) + create_patch(result, + filename_source_code, + loc_start, + loc_end, + old_str, + new_str) - name = get_name(element) - target_contract = slither.get_contract_from_name(name) - if not target_contract: - raise FormatError(f"Contract not found {name}") +def _explore_events_declaration(slither, events, result, target, convert): + for event in events: + # Explore the parameters + _explore_variables_declaration(slither, event.elems, result, target, convert) + + # If the event is the target + if event == target: + filename_source_code = event.source_mapping['filename_absolute'] + + old_str = event.name + new_str = convert(old_str) + + loc_start = event.source_mapping['start'] + loc_end = loc_start + len(old_str) - # Check state variables of contract type - # To-do: Deep-check aggregate types (struct and mapping) - svs = target_contract.variables - for sv in svs: - print(sv.type) - if (str(sv.type) == name): - old_str_of_interest = in_file_str[sv.source_mapping['start']:(sv.source_mapping['start'] + - sv.source_mapping['length'])] - # Get only the contract variable name even if it is initialised - (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(), - old_str_of_interest.decode('utf-8'), 1) create_patch(result, - in_file, - sv.source_mapping['start'], - sv.source_mapping['start'] + sv.source_mapping['length'], - old_str_of_interest.decode('utf-8'), - new_str_of_interest) - # Check function+modifier locals+parameters+returns - # To-do: Deep-check aggregate types (struct and mapping) - fms = target_contract.functions + target_contract.modifiers - for fm in fms: - for v in fm.variables: - if (str(v.type) == name): - old_str_of_interest = in_file_str[v.source_mapping['start']:(v.source_mapping['start'] + - v.source_mapping['length'])] - old_str_of_interest = old_str_of_interest.decode('utf-8').split('=')[0] - (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(),old_str_of_interest, 1) + filename_source_code, + loc_start, + loc_end, + old_str, + new_str) + +def get_ir_variables(ir): + vars = ir.read + + if isinstance(ir, (InternalCall, InternalDynamicCall, HighLevelCall)): + vars += [ir.function] + + if isinstance(ir, (HighLevelCall, Send, LowLevelCall, Transfer)): + vars += [ir.call_value] + + if isinstance(ir, (HighLevelCall, LowLevelCall)): + vars += [ir.call_gas] + + if isinstance(ir, OperationWithLValue): + vars += [ir.lvalue] + + return [v for v in vars if v] + +def _explore_irs(slither, irs, result, target, convert): + if irs is None: + return + for ir in irs: + for v in get_ir_variables(ir): + if target == v: + source_mapping = ir.expression.source_mapping + filename_source_code = source_mapping['filename_absolute'] + full_txt_start = source_mapping['start'] + full_txt_end = full_txt_start + source_mapping['length'] + full_txt = slither.source_code[filename_source_code][full_txt_start:full_txt_end] + + if not str(target) in full_txt: + raise FormatError(f'{target} not found in {full_txt} ({source_mapping}') + + if full_txt.count(str(target)) > 1: + raise FormatError(f'{target} found multiple times in {full_txt} ({source_mapping}') + + old_str = str(target) + new_str = convert(old_str) + + loc_start = full_txt_start + full_txt.find(str(target)) -1 + loc_end = loc_start + len(old_str) create_patch(result, - in_file, - v.source_mapping['start'], - v.source_mapping['start'] + len(old_str_of_interest), - old_str_of_interest, - new_str_of_interest) - - # Check "new" expressions for creation of contract objects - for function in target_contract.functions: - for node in function.nodes: - for ir in node.irs: - if isinstance(ir, NewContract) and ir.contract_name == name: - old_str_of_interest = in_file_str[node.source_mapping['start']:node.source_mapping['start'] + - node.source_mapping['length']] - # Search for the name after the `new` keyword - m = re.search("new"+r'(.*)'+name, old_str_of_interest.decode('utf-8')) - # Skip rare cases where re search fails. To-do: Investigate - if not m: - continue - old_str_of_interest = old_str_of_interest.decode('utf-8')[m.span()[0]:] - (new_str_of_interest, num_repl) = re.subn("new" + r'(.*)' + name, - "new" + r'\1' + name.capitalize(), - name[1:], old_str_of_interest, 1) - if num_repl != 0: - create_patch(result, - in_file, - # start after the `new` keyword where the name begins - node.source_mapping['start'] + m.span()[0], - node.source_mapping['start'] + m.span()[1], - old_str_of_interest, - new_str_of_interest) - else: - raise FormatError(f"Could not find new object {name}") - - -def _create_patch_modifier_uses(slither, result, element): - in_file, in_file_str, old_str_of_interest, loc_start, loc_end = _unpack_info(slither, element) - - name = get_name(element) - contract_name = get_contract_name(element) - - modifier_sig = element['type_specific_fields']['signature'] - - target_contract = slither.get_contract_from_name(contract_name) - if not target_contract: - raise FormatError(f"Contract not found {contract_name}") - - modifier_contract = target_contract.get_modifier_from_signature(modifier_sig) - - for function in target_contract.functions: - for m in function.modifiers: - if (m == modifier_contract): - f_modifier = m.source_mapping['filename_absolute'] - in_file_str = slither.source_code[f_modifier].encode('utf-8') - # Get the text from function parameters until the return statement or function body beginning - # This text will include parameter declarations, any Solidity keywords and modifier call - # Parameter names cannot collide with modifier name per Solidity rules - old_str_of_interest = in_file_str[int(function.parameters_src.source_mapping['start']): - int(function.returns_src.source_mapping['start'])] - # Change the first letter of the modifier name (if present) to lowercase - (new_str_of_interest, num_repl) = re.subn(name, name[0].lower()+name[1:], - old_str_of_interest.decode('utf-8'),1) - if num_repl != 0: - create_patch(result, - f_modifier, - int(function.parameters_src.source_mapping['start']), - int(function.returns_src.source_mapping['start']), - old_str_of_interest.decode('utf-8'), - new_str_of_interest) - else: - raise FormatError(f"Could not find modifier {modifier_sig}") - - - -def _create_patch_function_calls(slither, result, element): - in_file, in_file_str, old_str_of_interest, loc_start, loc_end = _unpack_info(slither, element) - name = get_name(element) - contract_name = get_contract_name(element) - - for contract in slither.contracts: - for function in contract.functions: - for node in function.nodes: - # Function call from another contract - for high_level_call in node.high_level_calls: - if (high_level_call[0].name == contract_name and high_level_call[1].name == name): - for external_call in node.external_calls_as_expressions: - # Check the called function name - called_function = str(external_call.called).split('.')[-1] - if called_function == high_level_call[1].name: - f_external_call = external_call.source_mapping['filename_absolute'] - in_file_str = slither.source_code[f_external_call].encode('utf-8') - old_str_of_interest = in_file_str[int(external_call.source_mapping['start']): - int(external_call.source_mapping['start']) + - int(external_call.source_mapping['length'])] - # Get the called function name. To-do: Check if we need to avoid parameters - called_function_name = old_str_of_interest.decode('utf-8').split('.')[-1] - # Convert first letter of name to lowercase - fixed_function_name = called_function_name[0].lower() + called_function_name[1:] - # Reconstruct the entire call - new_string = '.'.join(old_str_of_interest.decode('utf-8').split('.')[:-1]) + '.' + \ - fixed_function_name - create_patch(result, - f_external_call, - external_call.source_mapping['start'], - int(external_call.source_mapping['start']) + - int(external_call.source_mapping['length']), - old_str_of_interest.decode('utf-8'), - new_string) - # Function call from within same contract - for internal_call in node.internal_calls_as_expressions: - if (str(internal_call.called) == name): - f_internal_call = internal_call.source_mapping['filename_absolute'] - in_file_str = slither.source_code[f_internal_call].encode('utf-8') - old_str_of_interest = in_file_str[int(internal_call.source_mapping['start']): - int(internal_call.source_mapping['start']) + - int(internal_call.source_mapping['length'])] - # Get the called function name and avoid parameters - old_str_of_interest = old_str_of_interest.decode('utf-8').split('(')[0] - # Avoid parameters - # TODO: (JF) review me - end_loc = int(internal_call.source_mapping['start']) + \ - int(internal_call.source_mapping['length']) - \ - len('('.join(in_file_str[int(internal_call.source_mapping['start']): - int(internal_call.source_mapping['start']) + - int(internal_call.source_mapping['length'])] \ - .decode('utf-8').split('(')[1:])) - 1 - create_patch(result, - f_internal_call, - internal_call.source_mapping['start'], - end_loc, - old_str_of_interest, - old_str_of_interest[0].lower()+old_str_of_interest[1:]) - - - - -def _create_patch_event_calls(slither, result, element): - in_file, in_file_str, old_str_of_interest, loc_start, loc_end = _unpack_info(slither, element) - - name = get_name(element) - contract_name = get_contract_name(element) - - # Get only event name without parameters - event_name = name.split('(')[0] - target_contract = slither.get_contract_from_name(contract_name) - if not target_contract: - raise FormatError(f"Contract not found {name}") - for contract in [target_contract] + target_contract.derived_contracts: - for function in contract.functions: - for node in function.nodes: - for call in node.internal_calls_as_expressions: - if (str(call.called) == event_name): - f_call = call.source_mapping['filename_absolute'] - in_file_str = slither.source_code[f_call].encode('utf-8') - old_str_of_interest = in_file_str[int(call.source_mapping['start']): - int(call.source_mapping['start']) + - int(call.source_mapping['length'])] - - create_patch(result, - f_call, - call.source_mapping['start'], - int(call.source_mapping['start']) + int(call.source_mapping['length']), - old_str_of_interest.decode('utf-8'), - # Capitalize event name - old_str_of_interest.decode('utf-8').capitalize()) - - -def _create_patch_parameter_uses(slither, result, element): - - in_file, in_file_str, old_str_of_interest, loc_start, loc_end = _unpack_info(slither, element) - - name = get_name(element) - contract_name = get_contract_name(element) - - function_sig = element['type_specific_fields']['parent']['type_specific_fields']['signature'] - - target_contract = slither.get_contract_from_name(contract_name) - function = target_contract.get_function_from_signature(function_sig) - - for node in function.nodes: - # _expression_* are used to access the source mapping of the call rather - # than the body definition - vars = node._expression_vars_written + node._expression_vars_read - for v in vars: - if isinstance(v, Identifier) and str(v) == name and [str(lv) for lv in - (node._local_vars_read + - node._local_vars_written) - if str(lv) == name]: - # Skip rare cases where source_mapping is absent. To-do: Investigate - if not v.source_mapping: - continue - modify_loc_start = int(v.source_mapping['start']) - modify_loc_end = int(v.source_mapping['start']) + int(v.source_mapping['length']) - old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - # To-do: Change format logic below - how do we convert a name to mixedCase? - if(name[0] == '_'): - # If parameter name begins with underscore, capitalize the letter after underscore - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', - r'\1'+name[0]+name[1].upper()+name[2:] + - r'\2', old_str_of_interest.decode('utf-8'), - 1) - else: - # Add underscore and capitalize the first letter - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+'_' + - name.capitalize()+r'\2', - old_str_of_interest.decode('utf-8'), 1) - if num_repl != 0: - create_patch(result, - in_file, - modify_loc_start, - modify_loc_end, - old_str_of_interest.decode('utf-8'), - new_str_of_interest) - else: - raise FormatError(f"Could not find parameter use {name}") - - # Process function parameters passed to modifiers - # _expression_modifiers is used to access the source mapping of the call rather - # than the body definition - for modifier in function._expression_modifiers: - for arg in modifier.arguments: - if str(arg) == name: - old_str_of_interest = in_file_str[modifier.source_mapping['start']: - modifier.source_mapping['start'] + - modifier.source_mapping['length']] - # Get text beyond modifier name which contains parameters - old_str_of_interest_beyond_modifier_name = old_str_of_interest.decode('utf-8')\ - .split('(')[1] - # To-do: Change format logic below - how do we convert a name to mixedCase? - if(name[0] == '_'): - # If parameter name begins with underscore, capitalize the letter after underscore - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+name[0]+ - name[1].upper()+name[2:]+r'\2', - old_str_of_interest_beyond_modifier_name, 1) - else: - # Add underscore and capitalize the first letter - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name+r'(.*)', r'\1'+'_'+ - name.capitalize()+r'\2', - old_str_of_interest_beyond_modifier_name, 1) - if num_repl != 0: - create_patch(result, - in_file, - # Start beyond modifier name which contains parameters - modifier.source_mapping['start'] + - len(old_str_of_interest.decode('utf-8').split('(')[0]) + 1, - modifier.source_mapping['start'] + modifier.source_mapping['length'], - old_str_of_interest_beyond_modifier_name, - new_str_of_interest) - else: - raise FormatError(f"Could not find parameter use in modifier {modifier}") - - - -def _create_patch_state_variable_uses(slither, result, element): - name = get_name(element) - contract_name = get_contract_name(element) - - # To-do: Check cross-contract state variable uses - target_contract = slither.get_contract_from_name(contract_name) - if not target_contract: - raise FormatError(f"Contract not found {contract_name}") - - fms = target_contract.functions + target_contract.modifiers - for fm in fms: - for node in fm.nodes: - if not node.expression: - continue - visitor = ReadVarSyntactic(node.expression) - vars = visitor.result() - for v in vars: - if isinstance(v, Identifier) and str(v) == name and [str(sv) for sv in - (node._state_vars_read + - node._state_vars_written) - if str(sv) == name]: - modify_loc_start = int(v.source_mapping['start']) - modify_loc_end = int(v.source_mapping['start']) + int(v.source_mapping['length']) - f_function = fm.source_mapping['filename_absolute'] - in_file_str = slither.source_code[f_function].encode('utf-8') - old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] - if (element['additional_fields']['target'] == "variable_constant"): - # Convert constant state variables to upper case - new_str_of_interest = old_str_of_interest.decode('utf-8').upper() - else: - new_str_of_interest = old_str_of_interest.decode('utf-8') - new_str_of_interest = new_str_of_interest[0].lower()+new_str_of_interest[1:] - - create_patch(result, - f_function, - modify_loc_start, - modify_loc_end, - old_str_of_interest.decode('utf-8'), - new_str_of_interest) - - - -def _create_patch_enum_uses(slither, result, element): - in_file, in_file_str, old_str_of_interest, loc_start, loc_end = _unpack_info(slither, element) - - name = get_name(element) - contract_name = get_contract_name(element) - - target_contract = slither.get_contract_from_name(contract_name) - if not target_contract: - raise FormatError(f"Contract not found {contract_name}") - - in_file_str = slither.source_code[in_file].encode('utf-8') - # Check state variable declarations of enum type - # To-do: Deep-check aggregate types (struct and mapping) - svs = target_contract.variables - for sv in svs: - if (str(sv.type) == contract_name + "." + name): - old_str_of_interest = in_file_str[sv.source_mapping['start']:(sv.source_mapping['start']+ - sv.source_mapping['length'])] - (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(), - old_str_of_interest.decode('utf-8'), 1) + filename_source_code, + loc_start, + loc_end, + old_str, + new_str) + + +def _explore_functions(slither, functions, result, target, convert): + for function in functions: + _explore_variables_declaration(slither, function.local_variables, result, target, convert) + _explore_modifiers_calls(slither, function, result, target, convert) + _explore_irs(slither, function.all_slithir_operations(), result, target, convert) + + if function == target: + old_str = function.name + new_str = convert(old_str) + + filename_source_code = function.source_mapping['filename_absolute'] + full_txt_start = function.source_mapping['start'] + full_txt_end = full_txt_start + function.source_mapping['length'] + full_txt = slither.source_code[filename_source_code][full_txt_start:full_txt_end] + + # The name is after the space + matches = re.finditer('[function|modifier]([ ]*)', full_txt) + # Look for the end offset of the largest list of ' ' + loc_start = full_txt_start + max(matches, key=lambda x: len(x.group())).end() + loc_end = loc_start + len(old_str) create_patch(result, - in_file, - sv.source_mapping['start'], - sv.source_mapping['start'] + sv.source_mapping['length'], - old_str_of_interest.decode('utf-8'), - new_str_of_interest) - - # Check function+modifier locals+parameters+returns - # To-do: Deep-check aggregate types (struct and mapping) - fms = target_contract.functions + target_contract.modifiers - for fm in fms: - # Enum declarations - for v in fm.variables: - if (str(v.type) == contract_name + "." + name): - old_str_of_interest = in_file_str[v.source_mapping['start']:(v.source_mapping['start']+ - v.source_mapping['length'])] - (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(), - old_str_of_interest.decode('utf-8'), 1) + filename_source_code, + loc_start, + loc_end, + old_str, + new_str) + +def _explore_enums(slither, enums, result, target, convert): + for enum in enums: + if enum == target: + old_str = enum.name + new_str = convert(old_str) + + filename_source_code = enum.source_mapping['filename_absolute'] + full_txt_start = enum.source_mapping['start'] + full_txt_end = full_txt_start + enum.source_mapping['length'] + full_txt = slither.source_code[filename_source_code][full_txt_start:full_txt_end] + + # The name is after the space + matches = re.finditer('[enum]([ ]*)', full_txt) + # Look for the end offset of the largest list of ' ' + loc_start = full_txt_start + max(matches, key=lambda x: len(x.group())).end() + loc_end = loc_start + len(old_str) + + create_patch(result, + filename_source_code, + loc_start, + loc_end, + old_str, + new_str) + + +def _explore_contract(slither, contract, result, target, convert): + _explore_variables_declaration(slither, contract.state_variables, result, target, convert) + _explore_structures_declaration(slither, contract.structures, result, target, convert) + _explore_functions(slither, contract.functions_and_modifiers, result, target, convert) + _explore_enums(slither, contract.functions_and_modifiers, result, target, convert) + + if contract == target: + filename_source_code = contract.source_mapping['filename_absolute'] + full_txt_start = contract.source_mapping['start'] + full_txt_end = full_txt_start + contract.source_mapping['length'] + full_txt = slither.source_code[filename_source_code][full_txt_start:full_txt_end] + + old_str = contract.name + new_str = convert(old_str) + + # The name is after the space + matches = re.finditer('[contract][ ]*', full_txt) + # Look for the end offset of the largest list of ' ' + loc_start = full_txt_start + max(matches, key=lambda x: len(x.group())).end() + + loc_end = loc_start + len(old_str) + + create_patch(result, + filename_source_code, + loc_start, + loc_end, + old_str, + new_str) + + +def _explore(slither, result, target, convert): + for contract in slither.contracts_derived: + _explore_contract(slither, contract, result, target, convert) - create_patch(result, - in_file, - v.source_mapping['start'], - v.source_mapping['start'] + v.source_mapping['length'], - old_str_of_interest.decode('utf-8'), - new_str_of_interest) - - # Capture enum uses such as "num = numbers.ONE;" - for function in target_contract.functions: - for node in function.nodes: - for ir in node.irs: - if isinstance(ir, Member): - if str(ir.variable_left) == name: - # Skip past the assignment - old_str_of_interest = in_file_str[node.source_mapping['start']: - (node.source_mapping['start']+ - node.source_mapping['length'])].decode('utf-8')\ - .split('=')[1] - m = re.search(r'(.*)'+name, old_str_of_interest) - # Skip rare cases where re search fails. To-do: Investigate - if not m: - continue - old_str_of_interest = old_str_of_interest[m.span()[0]:] - (new_str_of_interest, num_repl) = re.subn(r'(.*)'+name, r'\1'+name.capitalize(), - old_str_of_interest, 1) - if num_repl != 0: - - # TODO (JF): review me - # Start past the assignment - loc_start = node.source_mapping['start'] + \ - len(in_file_str[node.source_mapping['start']: - (node.source_mapping['start']+ - node.source_mapping['length'])].decode('utf-8').split('=')[0]) + \ - 1 + m.span()[0] - - # End accounts for the assignment from the start - loc_end = node.source_mapping['start'] +\ - len(in_file_str[node.source_mapping['start']:(node.source_mapping['start']+ - node.source_mapping['length'])].\ - decode('utf-8').split('=')[0]) + 1 + m.span()[0] + len(old_str_of_interest) - - create_patch(result, - in_file, - loc_start, - loc_end, - old_str_of_interest, - new_str_of_interest) - - else: - raise FormatError(f"Could not find new object {function}") - # To-do: Check any other place/way where enum type is used - - - - - - -def _create_patch_struct_uses(slither, result, element): - in_file, in_file_str, old_str_of_interest, loc_start, loc_end = _unpack_info(slither, element) - - name = get_name(element) - contract_name = get_contract_name(element) - - target_contract = slither.get_contract_from_name(contract_name) - if not target_contract: - raise FormatError(f"Contract not found {contract_name}") - - for contract in [target_contract] + target_contract.derived_contracts: - f_contract = contract.source_mapping['filename_absolute'] - in_file_str = slither.source_code[f_contract].encode('utf-8') - # Check state variables of struct type - # To-do: Deep-check aggregate types (struct and mapping) - svs = contract.variables - for sv in svs: - if (str(sv.type) == contract_name + "." + name): - old_str_of_interest = in_file_str[sv.source_mapping['start']:(sv.source_mapping['start']+ - sv.source_mapping['length'])] - (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(), - old_str_of_interest.decode('utf-8'), 1) - create_patch(result, - f_contract, - sv.source_mapping['start'], - sv.source_mapping['start'] + sv.source_mapping['length'], - old_str_of_interest.decode('utf-8'), - new_str_of_interest) - # Check function+modifier locals+parameters+returns - # To-do: Deep-check aggregate types (struct and mapping) - fms = contract.functions + contract.modifiers - for fm in fms: - for v in fm.variables: - if (str(v.type) == contract_name + "." + name): - old_str_of_interest = in_file_str[v.source_mapping['start']:(v.source_mapping['start']+ - v.source_mapping['length'])] - (new_str_of_interest, num_repl) = re.subn(name, name.capitalize(), - old_str_of_interest.decode('utf-8'), 1) - - create_patch(result, - in_file, - v.source_mapping['start'], - v.source_mapping['start'] + v.source_mapping['length'], - old_str_of_interest.decode('utf-8'), - new_str_of_interest) - # To-do: Check any other place/way where struct type is used (e.g. typecast) - - - for st in contract.structures: - for elem in st.elems.values(): - if isinstance(elem.type, UserDefinedType): - if isinstance(elem.type.type, Structure): - if str(elem.type.type) == name: - old_str = str(elem.type.type) - new_str = name.capitalize() - - in_file = elem.source_mapping['filename_absolute'] - loc_start = elem.source_mapping['start'] - loc_end = loc_start + len(old_str) - - create_patch(result, - in_file, - loc_start, - loc_end, - old_str, - new_str) # endregion From 22f8ed731d68db5ef38c698a53bb988b343271a2 Mon Sep 17 00:00:00 2001 From: Josselin Date: Wed, 3 Jul 2019 16:18:51 +0200 Subject: [PATCH 090/223] Create ModifierStatements to allow IR conversion on modifier call --- slither/core/cfg/node.py | 4 +++ slither/core/declarations/function.py | 21 +++++++++++++++- slither/printers/summary/slithir.py | 8 ++++++ slither/solc_parsing/declarations/function.py | 25 ++++++++++++++++--- 4 files changed, 54 insertions(+), 4 deletions(-) diff --git a/slither/core/cfg/node.py b/slither/core/cfg/node.py index 0ff442a2b..8a94a7caa 100644 --- a/slither/core/cfg/node.py +++ b/slither/core/cfg/node.py @@ -62,6 +62,10 @@ class NodeType: # Only modifier node PLACEHOLDER = 0x40 + # Node not related to the CFG + # Use for state variable declaration, or modifier calls + STANDALONE = 0x50 + # @staticmethod def str(t): diff --git a/slither/core/declarations/function.py b/slither/core/declarations/function.py index b5fa6712c..6025f7829 100644 --- a/slither/core/declarations/function.py +++ b/slither/core/declarations/function.py @@ -15,10 +15,13 @@ from slither.core.expressions import (Identifier, IndexAccess, MemberAccess, from slither.core.source_mapping.source_mapping import SourceMapping from slither.core.variables.state_variable import StateVariable + logger = logging.getLogger("Function") ReacheableNode = namedtuple('ReacheableNode', ['node', 'ir']) +ModifierStatements = namedtuple('Modifier', ['modifier', 'node']) + class Function(ChildContract, ChildInheritance, SourceMapping): """ Function class @@ -324,6 +327,13 @@ class Function(ChildContract, ChildInheritance, SourceMapping): """ list(Modifier): List of the modifiers """ + return [c.modifier for c in self._modifiers] + + @property + def modifiers_statements(self): + """ + list(ModifierCall): List of the modifiers call (include expression and irs) + """ return list(self._modifiers) @property @@ -335,7 +345,16 @@ class Function(ChildContract, ChildInheritance, SourceMapping): included. """ # This is a list of contracts internally, so we convert it to a list of constructor functions. - return [c.constructors_declared for c in self._explicit_base_constructor_calls if c.constructors_declared] + return [c.modifier.constructors_declared for c in self._explicit_base_constructor_calls if c.modifier.constructors_declared] + + @property + def explicit_base_constructor_calls_statements(self): + """ + list(ModifierCall): List of the base constructors called explicitly by this presumed constructor definition. + + """ + # This is a list of contracts internally, so we convert it to a list of constructor functions. + return [c for c in self._explicit_base_constructor_calls if c.modifier.constructors_declared] # endregion diff --git a/slither/printers/summary/slithir.py b/slither/printers/summary/slithir.py index cd4a7299f..c6e30073f 100644 --- a/slither/printers/summary/slithir.py +++ b/slither/printers/summary/slithir.py @@ -34,6 +34,14 @@ class PrinterSlithIR(AbstractPrinter): print('\t\tIRs:') for ir in node.irs: print('\t\t\t{}'.format(ir)) + for modifier_statement in function.modifiers_statements: + print(f'\t\tModifier Call {modifier_statement.node.expression}') + for ir in modifier_statement.node.irs: + print('\t\t\t{}'.format(ir)) + for modifier_statement in function.explicit_base_constructor_calls_statements: + print(f'\t\tConstructor Call {modifier_statement.node.expression}') + for ir in modifier_statement.node.irs: + print('\t\t\t{}'.format(ir)) for modifier in contract.modifiers: print('\tModifier {}'.format(modifier.canonical_name)) for node in modifier.nodes: diff --git a/slither/solc_parsing/declarations/function.py b/slither/solc_parsing/declarations/function.py index 721f49941..6da6233c5 100644 --- a/slither/solc_parsing/declarations/function.py +++ b/slither/solc_parsing/declarations/function.py @@ -4,7 +4,7 @@ import logging from slither.core.cfg.node import NodeType, link_nodes from slither.core.declarations.contract import Contract -from slither.core.declarations.function import Function +from slither.core.declarations.function import Function, ModifierStatements from slither.core.dominators.utils import (compute_dominance_frontier, compute_dominators) from slither.core.expressions import AssignmentOperation @@ -220,6 +220,12 @@ class FunctionSolc(Function): for node in self.nodes: node.analyze_expressions(self) + for modifier_statement in self.modifiers_statements: + modifier_statement.node.analyze_expressions(self) + + for modifier_statement in self.explicit_base_constructor_calls_statements: + modifier_statement.node.analyze_expressions(self) + self._filter_ternary() self._remove_alone_endif() @@ -897,9 +903,15 @@ class FunctionSolc(Function): self._expression_modifiers.append(m) for m in ExportValues(m).result(): if isinstance(m, Function): - self._modifiers.append(m) + node = self._new_node(NodeType.STANDALONE, modifier['src']) + node.add_unparsed_expression(modifier) + self._modifiers.append(ModifierStatements(modifier=m, + node=node)) elif isinstance(m, Contract): - self._explicit_base_constructor_calls.append(m) + node = self._new_node(NodeType.STANDALONE, modifier['src']) + node.add_unparsed_expression(modifier) + self._explicit_base_constructor_calls.append(ModifierStatements(modifier=m, + node=node)) # endregion ################################################################################### @@ -1122,6 +1134,13 @@ class FunctionSolc(Function): def generate_slithir_and_analyze(self): for node in self.nodes: node.slithir_generation() + + for modifier_statement in self.modifiers_statements: + modifier_statement.node.slithir_generation() + + for modifier_statement in self.explicit_base_constructor_calls_statements: + modifier_statement.node.slithir_generation() + self._analyze_read_write() self._analyze_calls() From 8879453a2757775beae904e7dc9cc3d4f3b6bf4b Mon Sep 17 00:00:00 2001 From: Josselin Date: Wed, 3 Jul 2019 16:35:30 +0200 Subject: [PATCH 091/223] Fix minor bugs + add modifier support --- .../formatters/naming_convention.py | 30 ++++++++++--------- 1 file changed, 16 insertions(+), 14 deletions(-) diff --git a/utils/slither_format/formatters/naming_convention.py b/utils/slither_format/formatters/naming_convention.py index 19c248b0e..3a1251f40 100644 --- a/utils/slither_format/formatters/naming_convention.py +++ b/utils/slither_format/formatters/naming_convention.py @@ -1,10 +1,8 @@ import re import logging -from slither.core.expressions.identifier import Identifier -from slither.slithir.operations import NewContract -from slither.slithir.operations import Member, Send, Transfer, OperationWithLValue, HighLevelCall, LowLevelCall, \ +from slither.slithir.operations import Send, Transfer, OperationWithLValue, HighLevelCall, LowLevelCall, \ InternalCall, InternalDynamicCall -from slither.visitors.expression.read_var_syntactic import ReadVarSyntactic +from slither.core.declarations import Modifier from slither.core.solidity_types import UserDefinedType, MappingType from slither.core.declarations import Enum, Contract, Structure from ..exceptions import FormatError @@ -324,10 +322,10 @@ def _explore_variables_declaration(slither, variables, result, target, convert): def _explore_modifiers_calls(slither, function, result, target, convert): - pass - #for modifier in function._expression_modifiers: - # print(type(modifier)) - + for modifier in function.modifiers_statements: + _explore_irs(slither, modifier.node.irs, result, target, convert) + for modifier in function.explicit_base_constructor_calls_statements: + _explore_irs(slither, modifier.node.irs, result, target, convert) def _explore_structures_declaration(slither, structures, result, target, convert): for st in structures: @@ -345,7 +343,7 @@ def _explore_structures_declaration(slither, structures, result, target, convert full_txt = slither.source_code[filename_source_code][full_txt_start:full_txt_end] # The name is after the space - matches = re.finditer('[struct][ ]*', full_txt) + matches = re.finditer('struct[ ]*', full_txt) # Look for the end offset of the largest list of ' ' loc_start = full_txt_start + max(matches, key=lambda x: len(x.group())).end() loc_end = loc_start + len(old_str) @@ -418,7 +416,7 @@ def _explore_irs(slither, irs, result, target, convert): old_str = str(target) new_str = convert(old_str) - loc_start = full_txt_start + full_txt.find(str(target)) -1 + loc_start = full_txt_start + full_txt.find(str(target)) loc_end = loc_start + len(old_str) create_patch(result, @@ -445,7 +443,10 @@ def _explore_functions(slither, functions, result, target, convert): full_txt = slither.source_code[filename_source_code][full_txt_start:full_txt_end] # The name is after the space - matches = re.finditer('[function|modifier]([ ]*)', full_txt) + if isinstance(target, Modifier): + matches = re.finditer('modifier([ ]*)', full_txt) + else: + matches = re.finditer('function([ ]*)', full_txt) # Look for the end offset of the largest list of ' ' loc_start = full_txt_start + max(matches, key=lambda x: len(x.group())).end() loc_end = loc_start + len(old_str) @@ -460,6 +461,7 @@ def _explore_functions(slither, functions, result, target, convert): def _explore_enums(slither, enums, result, target, convert): for enum in enums: if enum == target: + print(target) old_str = enum.name new_str = convert(old_str) @@ -469,7 +471,7 @@ def _explore_enums(slither, enums, result, target, convert): full_txt = slither.source_code[filename_source_code][full_txt_start:full_txt_end] # The name is after the space - matches = re.finditer('[enum]([ ]*)', full_txt) + matches = re.finditer('enum([ ]*)', full_txt) # Look for the end offset of the largest list of ' ' loc_start = full_txt_start + max(matches, key=lambda x: len(x.group())).end() loc_end = loc_start + len(old_str) @@ -486,7 +488,7 @@ def _explore_contract(slither, contract, result, target, convert): _explore_variables_declaration(slither, contract.state_variables, result, target, convert) _explore_structures_declaration(slither, contract.structures, result, target, convert) _explore_functions(slither, contract.functions_and_modifiers, result, target, convert) - _explore_enums(slither, contract.functions_and_modifiers, result, target, convert) + _explore_enums(slither, contract.enums, result, target, convert) if contract == target: filename_source_code = contract.source_mapping['filename_absolute'] @@ -498,7 +500,7 @@ def _explore_contract(slither, contract, result, target, convert): new_str = convert(old_str) # The name is after the space - matches = re.finditer('[contract][ ]*', full_txt) + matches = re.finditer('contract[ ]*', full_txt) # Look for the end offset of the largest list of ' ' loc_start = full_txt_start + max(matches, key=lambda x: len(x.group())).end() From 12a5a75b38544f1b8d249b663fe6e43012d4bc34 Mon Sep 17 00:00:00 2001 From: Josselin Date: Wed, 3 Jul 2019 17:43:53 +0200 Subject: [PATCH 092/223] Fix filter-paths argument in case of raw directory (fix #292) --- slither/__main__.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/slither/__main__.py b/slither/__main__.py index 06fabe1a9..6c66d6bbc 100644 --- a/slither/__main__.py +++ b/slither/__main__.py @@ -46,7 +46,6 @@ def process(filename, args, detector_classes, printer_classes): ast = '--ast-compact-json' if args.legacy_ast: ast = '--ast-json' - args.filter_paths = parse_filter_paths(args) slither = Slither(filename, ast_format=ast, **vars(args)) @@ -85,7 +84,6 @@ def process_files(filenames, args, detector_classes, printer_classes): all_contracts.append(contract_loaded['ast']) slither = Slither(all_contracts, - filter_paths=parse_filter_paths(args), **vars(args)) return _process(slither, detector_classes, printer_classes) @@ -423,6 +421,8 @@ def parse_args(detector_classes, printer_classes): args = parser.parse_args() read_config_file(args) + args.filter_paths = parse_filter_paths(args) + return args class ListDetectors(argparse.Action): From 3d43c3c14815a5b8b0165cb317e083032e5ce95e Mon Sep 17 00:00:00 2001 From: Josselin Date: Wed, 3 Jul 2019 18:06:30 +0200 Subject: [PATCH 093/223] Minor fixes --- utils/slither_format/formatters/naming_convention.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/utils/slither_format/formatters/naming_convention.py b/utils/slither_format/formatters/naming_convention.py index 3a1251f40..30ae27ad7 100644 --- a/utils/slither_format/formatters/naming_convention.py +++ b/utils/slither_format/formatters/naming_convention.py @@ -126,7 +126,7 @@ def _patch(slither, result, element, _target): elif _target == "parameter": contract_name = element['type_specific_fields']['parent']['type_specific_fields']['parent']['name'] - function_sig = element['type_specific_fields']['parent']['signature'] + function_sig = element['type_specific_fields']['parent']['type_specific_fields']['signature'] param_name = element['name'] contract = slither.get_contract_from_name(contract_name) function = contract.get_function_from_signature(function_sig) @@ -136,7 +136,7 @@ def _patch(slither, result, element, _target): # Local variable if element['type_specific_fields']['parent'] == 'function': contract_name = element['type_specific_fields']['parent']['type_specific_fields']['parent']['name'] - function_sig = element['type_specific_fields']['parent']['signature'] + function_sig = element['type_specific_fields']['parent']['type_specific_fields']['signature'] var_name = element['name'] contract = slither.get_contract_from_name(contract_name) function = contract.get_function_from_signature(function_sig) @@ -144,13 +144,13 @@ def _patch(slither, result, element, _target): # State variable else: contract_name = element['type_specific_fields']['parent']['name'] - var_name = element['type_specific_fields']['name'] + var_name = element['name'] contract = slither.get_contract_from_name(contract_name) target = contract.get_state_variable_from_name(var_name) elif _target == "enum": contract_name = element['type_specific_fields']['parent']['name'] - enum_name = element['type_specific_fields']['name'] + enum_name = element['name'] contract = slither.get_contract_from_name(contract_name) target = contract.get_enum_from_canonical_name(enum_name) From 8da3b86a306a62300f6aa981a95045380924f620 Mon Sep 17 00:00:00 2001 From: Josselin Date: Fri, 5 Jul 2019 13:29:56 +0200 Subject: [PATCH 094/223] Add a new type of function: constructor_variable to hold state variable initialization Add Function.FunctionType to determine if the function is a constructor/fallback/constructor_variables API change: function.is_fallback() becomes a property --- slither/core/declarations/function.py | 209 ++++++++++++++++-- slither/solc_parsing/declarations/contract.py | 47 +++- slither/solc_parsing/declarations/function.py | 142 ++---------- slither/solc_parsing/slitherSolc.py | 4 + 4 files changed, 252 insertions(+), 150 deletions(-) diff --git a/slither/core/declarations/function.py b/slither/core/declarations/function.py index 6025f7829..631e262bf 100644 --- a/slither/core/declarations/function.py +++ b/slither/core/declarations/function.py @@ -4,6 +4,7 @@ import logging from collections import namedtuple from itertools import groupby +from enum import Enum from slither.core.children.child_contract import ChildContract from slither.core.children.child_inheritance import ChildInheritance @@ -13,8 +14,9 @@ from slither.core.declarations.solidity_variables import (SolidityFunction, from slither.core.expressions import (Identifier, IndexAccess, MemberAccess, UnaryOperation) from slither.core.source_mapping.source_mapping import SourceMapping -from slither.core.variables.state_variable import StateVariable +from slither.core.variables.state_variable import StateVariable +from slither.utils.utils import unroll logger = logging.getLogger("Function") @@ -22,6 +24,12 @@ ReacheableNode = namedtuple('ReacheableNode', ['node', 'ir']) ModifierStatements = namedtuple('Modifier', ['modifier', 'node']) +class FunctionType(Enum): + NORMAL = 0 + CONSTRUCTOR = 1 + FALLBACK = 2 + CONSTRUCTOR_VARIABLES = 3 # Fake function to hold variable declaration statements + class Function(ChildContract, ChildInheritance, SourceMapping): """ Function class @@ -34,7 +42,7 @@ class Function(ChildContract, ChildInheritance, SourceMapping): self._pure = None self._payable = None self._visibility = None - self._is_constructor = None + self._is_implemented = None self._is_empty = None self._entry_point = None @@ -94,6 +102,9 @@ class Function(ChildContract, ChildInheritance, SourceMapping): self._reachable_from_nodes = set() self._reachable_from_functions = set() + # Constructor, fallback, State variable constructor + self._function_type = None + self._is_constructor = None ################################################################################### ################################################################################### @@ -106,11 +117,12 @@ class Function(ChildContract, ChildInheritance, SourceMapping): """ str: function name """ - if self._name == '': - if self.is_constructor: - return 'constructor' - else: - return 'fallback' + if self._function_type == FunctionType.CONSTRUCTOR: + return 'constructor' + elif self._function_type == FunctionType.FALLBACK: + return 'fallback' + elif self._function_type == FunctionType.CONSTRUCTOR_VARIABLES: + return 'slither_constructor_variables' return self._name @property @@ -131,12 +143,6 @@ class Function(ChildContract, ChildInheritance, SourceMapping): name, parameters, _ = self.signature return self.contract_declarer.name + '.' + name + '(' + ','.join(parameters) + ')' - @property - def is_constructor(self): - """ - bool: True if the function is the constructor - """ - return self._is_constructor or self._name == self.contract_declarer.name @property def contains_assembly(self): @@ -154,6 +160,41 @@ class Function(ChildContract, ChildInheritance, SourceMapping): """ return self.contract_declarer == contract + # endregion + ################################################################################### + ################################################################################### + # region Type (FunctionType) + ################################################################################### + ################################################################################### + + def set_function_type(self, t): + assert isinstance(t, FunctionType) + self._function_type = t + + @property + def is_constructor(self): + """ + bool: True if the function is the constructor + """ + return self._function_type == FunctionType.CONSTRUCTOR + + @property + def is_constructor_variables(self): + """ + bool: True if the function is the constructor of the variables + Slither has a inbuilt function to hold the state variables initialization + """ + return self._function_type == FunctionType.CONSTRUCTOR_VARIABLES + + @property + def is_fallback(self): + """ + Determine if the function is the fallback function for the contract + Returns + (bool) + """ + return self._function_type == FunctionType.FALLBACK + # endregion ################################################################################### ################################################################################### @@ -182,6 +223,9 @@ class Function(ChildContract, ChildInheritance, SourceMapping): """ return self._visibility + def set_visibility(self, v): + self._visibility = v + @property def view(self): """ @@ -248,6 +292,11 @@ class Function(ChildContract, ChildInheritance, SourceMapping): """ return self._entry_point + def add_node(self, node): + if not self._entry_point: + self._entry_point = node + self._nodes.append(node) + # endregion ################################################################################### ################################################################################### @@ -1005,13 +1054,6 @@ class Function(ChildContract, ChildInheritance, SourceMapping): args_vars = self.all_solidity_variables_used_as_args() return SolidityVariableComposed('msg.sender') in conditional_vars + args_vars - def is_fallback(self): - """ - Determine if the function is the fallback function for the contract - Returns - (bool) - """ - return self._name == "" and not self.is_constructor # endregion ################################################################################### @@ -1119,6 +1161,133 @@ class Function(ChildContract, ChildInheritance, SourceMapping): # endregion + ################################################################################### + ################################################################################### + # region SlithIr and SSA + ################################################################################### + ################################################################################### + + def get_last_ssa_state_variables_instances(self): + from slither.slithir.variables import ReferenceVariable + from slither.slithir.operations import OperationWithLValue + from slither.core.cfg.node import NodeType + + if not self.is_implemented: + return dict() + + # node, values + to_explore = [(self._entry_point, dict())] + # node -> values + explored = dict() + # name -> instances + ret = dict() + + while to_explore: + node, values = to_explore[0] + to_explore = to_explore[1::] + + if node.type != NodeType.ENTRYPOINT: + for ir_ssa in node.irs_ssa: + if isinstance(ir_ssa, OperationWithLValue): + lvalue = ir_ssa.lvalue + if isinstance(lvalue, ReferenceVariable): + lvalue = lvalue.points_to_origin + if isinstance(lvalue, StateVariable): + values[lvalue.canonical_name] = {lvalue} + + # Check for fixpoint + if node in explored: + if values == explored[node]: + continue + for k, instances in values.items(): + if not k in explored[node]: + explored[node][k] = set() + explored[node][k] |= instances + values = explored[node] + else: + explored[node] = values + + # Return condition + if not node.sons and node.type != NodeType.THROW: + for name, instances in values.items(): + if name not in ret: + ret[name] = set() + ret[name] |= instances + + for son in node.sons: + to_explore.append((son, dict(values))) + + return ret + + @staticmethod + def _unchange_phi(ir): + from slither.slithir.operations import (Phi, PhiCallback) + if not isinstance(ir, (Phi, PhiCallback)) or len(ir.rvalues) > 1: + return False + if not ir.rvalues: + return True + return ir.rvalues[0] == ir.lvalue + + def fix_phi(self, last_state_variables_instances, initial_state_variables_instances): + from slither.slithir.operations import (InternalCall, PhiCallback) + from slither.slithir.variables import (Constant, StateIRVariable) + for node in self.nodes: + for ir in node.irs_ssa: + if node == self.entry_point: + if isinstance(ir.lvalue, StateIRVariable): + additional = [initial_state_variables_instances[ir.lvalue.canonical_name]] + additional += last_state_variables_instances[ir.lvalue.canonical_name] + ir.rvalues = list(set(additional + ir.rvalues)) + # function parameter + else: + # find index of the parameter + idx = self.parameters.index(ir.lvalue.non_ssa_version) + # find non ssa version of that index + additional = [n.ir.arguments[idx] for n in self.reachable_from_nodes] + additional = unroll(additional) + additional = [a for a in additional if not isinstance(a, Constant)] + ir.rvalues = list(set(additional + ir.rvalues)) + if isinstance(ir, PhiCallback): + callee_ir = ir.callee_ir + if isinstance(callee_ir, InternalCall): + last_ssa = callee_ir.function.get_last_ssa_state_variables_instances() + if ir.lvalue.canonical_name in last_ssa: + ir.rvalues = list(last_ssa[ir.lvalue.canonical_name]) + else: + ir.rvalues = [ir.lvalue] + else: + additional = last_state_variables_instances[ir.lvalue.canonical_name] + ir.rvalues = list(set(additional + ir.rvalues)) + + node.irs_ssa = [ir for ir in node.irs_ssa if not self._unchange_phi(ir)] + + def generate_slithir_and_analyze(self): + for node in self.nodes: + node.slithir_generation() + + for modifier_statement in self.modifiers_statements: + modifier_statement.node.slithir_generation() + + for modifier_statement in self.explicit_base_constructor_calls_statements: + modifier_statement.node.slithir_generation() + + self._analyze_read_write() + self._analyze_calls() + + def generate_slithir_ssa(self, all_ssa_state_variables_instances): + from slither.slithir.utils.ssa import add_ssa_ir, transform_slithir_vars_to_ssa + from slither.core.dominators.utils import (compute_dominance_frontier, + compute_dominators) + compute_dominators(self.nodes) + compute_dominance_frontier(self.nodes) + transform_slithir_vars_to_ssa(self) + add_ssa_ir(self, all_ssa_state_variables_instances) + + def update_read_write_using_ssa(self): + for node in self.nodes: + node.update_read_write_using_ssa() + self._analyze_read_write() + ################################################################################### ################################################################################### # region Built in definitions diff --git a/slither/solc_parsing/declarations/contract.py b/slither/solc_parsing/declarations/contract.py index d3a01c51f..f5fba278c 100644 --- a/slither/solc_parsing/declarations/contract.py +++ b/slither/solc_parsing/declarations/contract.py @@ -1,7 +1,10 @@ import logging from slither.core.declarations.contract import Contract +from slither.core.declarations.function import Function, FunctionType from slither.core.declarations.enum import Enum +from slither.core.cfg.node import Node, NodeType +from slither.core.expressions import AssignmentOperation, Identifier, AssignmentOperationType from slither.slithir.variables import StateIRVariable from slither.solc_parsing.declarations.event import EventSolc from slither.solc_parsing.declarations.function import FunctionSolc @@ -319,7 +322,6 @@ class ContractSolc04(Contract): :return: """ all_elements = {} - accessible_elements = {} for father in self.inheritance: for element in getter(father): @@ -368,6 +370,49 @@ class ContractSolc04(Contract): pass return + + def _create_node(self, func, counter, variable): + # Function uses to create node for state variable declaration statements + node = Node(NodeType.STANDALONE, counter) + node.set_offset(variable.source_mapping, self.slither) + node.set_function(func) + func.add_node(node) + print(variable.expression) + expression = AssignmentOperation(Identifier(variable), + variable.expression, + AssignmentOperationType.ASSIGN, + variable.type) + + node.add_expression(expression) + return node + + def add_constructor_variables(self): + if self.state_variables: + found_candidate = False + for (idx, variable_candidate) in enumerate(self.state_variables): + if variable_candidate.expression and not variable_candidate.is_constant: + found_candidate = True + break + if found_candidate: + constructor_variable = Function() + constructor_variable.set_function_type(FunctionType.CONSTRUCTOR_VARIABLES) + constructor_variable.set_contract(self) + constructor_variable.set_contract_declarer(self) + constructor_variable.set_visibility('internal') + self._functions[constructor_variable.canonical_name] = constructor_variable + + prev_node = self._create_node(constructor_variable, 0, variable_candidate) + counter = 1 + for v in self.state_variables[idx+1:]: + if v.expression and not v.is_constant: + next_node = self._create_node(constructor_variable, counter, v) + prev_node.add_son(next_node) + next_node.add_father(prev_node) + counter += 1 + + + + def analyze_state_variables(self): for var in self.variables: var.analyze(self) diff --git a/slither/solc_parsing/declarations/function.py b/slither/solc_parsing/declarations/function.py index 6da6233c5..5c95cc231 100644 --- a/slither/solc_parsing/declarations/function.py +++ b/slither/solc_parsing/declarations/function.py @@ -4,16 +4,10 @@ import logging from slither.core.cfg.node import NodeType, link_nodes from slither.core.declarations.contract import Contract -from slither.core.declarations.function import Function, ModifierStatements -from slither.core.dominators.utils import (compute_dominance_frontier, - compute_dominators) +from slither.core.declarations.function import Function, ModifierStatements, FunctionType + from slither.core.expressions import AssignmentOperation -from slither.core.variables.state_variable import StateVariable -from slither.slithir.operations import (InternalCall, OperationWithLValue, Phi, - PhiCallback) -from slither.slithir.utils.ssa import add_ssa_ir, transform_slithir_vars_to_ssa -from slither.slithir.variables import (Constant, ReferenceVariable, - StateIRVariable) + from slither.solc_parsing.cfg.node import NodeSolc from slither.solc_parsing.expressions.expression_parsing import \ parse_expression @@ -23,7 +17,6 @@ from slither.solc_parsing.variables.local_variable_init_from_tuple import \ from slither.solc_parsing.variables.variable_declaration import \ MultipleVariablesDeclaration from slither.utils.expression_manipulations import SplitTernaryExpression -from slither.utils.utils import unroll from slither.visitors.expression.export_values import ExportValues from slither.visitors.expression.has_conditional import HasConditional from slither.solc_parsing.exceptions import ParsingError @@ -139,14 +132,20 @@ class FunctionSolc(Function): if 'constant' in attributes: self._view = attributes['constant'] - self._is_constructor = False + if self._name == '': + self._function_type = FunctionType.FALLBACK + else: + self._function_type = FunctionType.NORMAL + + if self._name == self.contract_declarer.name: + self._function_type = FunctionType.CONSTRUCTOR - if 'isConstructor' in attributes: - self._is_constructor = attributes['isConstructor'] + if 'isConstructor' in attributes and attributes['isConstructor']: + self._function_type = FunctionType.CONSTRUCTOR if 'kind' in attributes: if attributes['kind'] == 'constructor': - self._is_constructor = True + self._function_type = FunctionType.CONSTRUCTOR if 'visibility' in attributes: self._visibility = attributes['visibility'] @@ -1038,120 +1037,5 @@ class FunctionSolc(Function): # endregion - ################################################################################### - ################################################################################### - # region SlithIr and SSA - ################################################################################### - ################################################################################### - - def get_last_ssa_state_variables_instances(self): - if not self.is_implemented: - return dict() - - # node, values - to_explore = [(self._entry_point, dict())] - # node -> values - explored = dict() - # name -> instances - ret = dict() - - while to_explore: - node, values = to_explore[0] - to_explore = to_explore[1::] - - if node.type != NodeType.ENTRYPOINT: - for ir_ssa in node.irs_ssa: - if isinstance(ir_ssa, OperationWithLValue): - lvalue = ir_ssa.lvalue - if isinstance(lvalue, ReferenceVariable): - lvalue = lvalue.points_to_origin - if isinstance(lvalue, StateVariable): - values[lvalue.canonical_name] = {lvalue} - - # Check for fixpoint - if node in explored: - if values == explored[node]: - continue - for k, instances in values.items(): - if not k in explored[node]: - explored[node][k] = set() - explored[node][k] |= instances - values = explored[node] - else: - explored[node] = values - - # Return condition - if not node.sons and node.type != NodeType.THROW: - for name, instances in values.items(): - if name not in ret: - ret[name] = set() - ret[name] |= instances - - for son in node.sons: - to_explore.append((son, dict(values))) - return ret - - @staticmethod - def _unchange_phi(ir): - if not isinstance(ir, (Phi, PhiCallback)) or len(ir.rvalues) > 1: - return False - if not ir.rvalues: - return True - return ir.rvalues[0] == ir.lvalue - - def fix_phi(self, last_state_variables_instances, initial_state_variables_instances): - for node in self.nodes: - for ir in node.irs_ssa: - if node == self.entry_point: - if isinstance(ir.lvalue, StateIRVariable): - additional = [initial_state_variables_instances[ir.lvalue.canonical_name]] - additional += last_state_variables_instances[ir.lvalue.canonical_name] - ir.rvalues = list(set(additional + ir.rvalues)) - # function parameter - else: - # find index of the parameter - idx = self.parameters.index(ir.lvalue.non_ssa_version) - # find non ssa version of that index - additional = [n.ir.arguments[idx] for n in self.reachable_from_nodes] - additional = unroll(additional) - additional = [a for a in additional if not isinstance(a, Constant)] - ir.rvalues = list(set(additional + ir.rvalues)) - if isinstance(ir, PhiCallback): - callee_ir = ir.callee_ir - if isinstance(callee_ir, InternalCall): - last_ssa = callee_ir.function.get_last_ssa_state_variables_instances() - if ir.lvalue.canonical_name in last_ssa: - ir.rvalues = list(last_ssa[ir.lvalue.canonical_name]) - else: - ir.rvalues = [ir.lvalue] - else: - additional = last_state_variables_instances[ir.lvalue.canonical_name] - ir.rvalues = list(set(additional + ir.rvalues)) - - node.irs_ssa = [ir for ir in node.irs_ssa if not self._unchange_phi(ir)] - - def generate_slithir_and_analyze(self): - for node in self.nodes: - node.slithir_generation() - - for modifier_statement in self.modifiers_statements: - modifier_statement.node.slithir_generation() - - for modifier_statement in self.explicit_base_constructor_calls_statements: - modifier_statement.node.slithir_generation() - - self._analyze_read_write() - self._analyze_calls() - - def generate_slithir_ssa(self, all_ssa_state_variables_instances): - compute_dominators(self.nodes) - compute_dominance_frontier(self.nodes) - transform_slithir_vars_to_ssa(self) - add_ssa_ir(self, all_ssa_state_variables_instances) - - def update_read_write_using_ssa(self): - for node in self.nodes: - node.update_read_write_using_ssa() - self._analyze_read_write() diff --git a/slither/solc_parsing/slitherSolc.py b/slither/solc_parsing/slitherSolc.py index 6d11e2cc8..e6ac1c932 100644 --- a/slither/solc_parsing/slitherSolc.py +++ b/slither/solc_parsing/slitherSolc.py @@ -373,10 +373,14 @@ class SlitherSolc(Slither): contract.analyze_content_modifiers() contract.analyze_content_functions() + + contract.set_is_analyzed(True) def _convert_to_slithir(self): + for contract in self.contracts: + contract.add_constructor_variables() contract.convert_expression_to_slithir() self._propagate_function_calls() for contract in self.contracts: From 5b636f5b4312afb467d98d1f6a135cf8e3376b9b Mon Sep 17 00:00:00 2001 From: Josselin Date: Fri, 5 Jul 2019 13:41:16 +0200 Subject: [PATCH 095/223] Improve constructor call support --- slither/slithir/convert.py | 6 ++++++ slither/slithir/tmp_operations/tmp_call.py | 9 ++++----- 2 files changed, 10 insertions(+), 5 deletions(-) diff --git a/slither/slithir/convert.py b/slither/slithir/convert.py index 63284db77..101604d55 100644 --- a/slither/slithir/convert.py +++ b/slither/slithir/convert.py @@ -586,6 +586,12 @@ def extract_tmp_call(ins, contract): if isinstance(ins.called, Event): return EventCall(ins.called.name) + if isinstance(ins.called, Contract): + internalcall = InternalCall(ins.called.constructor, ins.nbr_arguments, ins.lvalue, + ins.type_call) + internalcall.call_id = ins.call_id + return internalcall + raise Exception('Not extracted {} {}'.format(type(ins.called), ins)) diff --git a/slither/slithir/tmp_operations/tmp_call.py b/slither/slithir/tmp_operations/tmp_call.py index 0d7fda1e9..3c8faec3c 100644 --- a/slither/slithir/tmp_operations/tmp_call.py +++ b/slither/slithir/tmp_operations/tmp_call.py @@ -1,14 +1,13 @@ -from slither.slithir.operations.lvalue import OperationWithLValue +from slither.core.declarations import Event, Contract, SolidityVariableComposed, SolidityFunction, Structure from slither.core.variables.variable import Variable -from slither.core.declarations.solidity_variables import SolidityVariableComposed, SolidityFunction -from slither.core.declarations.structure import Structure -from slither.core.declarations.event import Event +from slither.slithir.operations.lvalue import OperationWithLValue class TmpCall(OperationWithLValue): def __init__(self, called, nbr_arguments, result, type_call): - assert isinstance(called, (Variable, + assert isinstance(called, (Contract, + Variable, SolidityVariableComposed, SolidityFunction, Structure, From ce4485317795f8361c8a3975d5ed5ba1bdcbfd0c Mon Sep 17 00:00:00 2001 From: Josselin Date: Fri, 5 Jul 2019 15:25:14 +0200 Subject: [PATCH 096/223] Minor fixes Fix travis --- scripts/tests_generate_expected_json_4.sh | 2 +- slither/core/declarations/function.py | 2 +- .../possible_const_state_variables.py | 2 +- slither/solc_parsing/declarations/contract.py | 1 - ...deprecated_calls.deprecated-standards.json | 80 +++++++++++++++++++ .../deprecated_calls.deprecated-standards.txt | 4 +- utils/similarity/encode.py | 2 +- 7 files changed, 87 insertions(+), 6 deletions(-) diff --git a/scripts/tests_generate_expected_json_4.sh b/scripts/tests_generate_expected_json_4.sh index 4e1def80c..e748e4f42 100755 --- a/scripts/tests_generate_expected_json_4.sh +++ b/scripts/tests_generate_expected_json_4.sh @@ -21,7 +21,7 @@ generate_expected_json(){ } -#generate_expected_json tests/deprecated_calls.sol "deprecated-standards" +generate_expected_json tests/deprecated_calls.sol "deprecated-standards" #generate_expected_json tests/erc20_indexed.sol "erc20-indexed" #generate_expected_json tests/incorrect_erc20_interface.sol "erc20-interface" #generate_expected_json tests/incorrect_erc721_interface.sol "erc721-interface" diff --git a/slither/core/declarations/function.py b/slither/core/declarations/function.py index 631e262bf..7243a7c03 100644 --- a/slither/core/declarations/function.py +++ b/slither/core/declarations/function.py @@ -122,7 +122,7 @@ class Function(ChildContract, ChildInheritance, SourceMapping): elif self._function_type == FunctionType.FALLBACK: return 'fallback' elif self._function_type == FunctionType.CONSTRUCTOR_VARIABLES: - return 'slither_constructor_variables' + return 'slitherConstructorVariables' return self._name @property diff --git a/slither/detectors/variables/possible_const_state_variables.py b/slither/detectors/variables/possible_const_state_variables.py index f062a0c7a..9d30bcfcf 100644 --- a/slither/detectors/variables/possible_const_state_variables.py +++ b/slither/detectors/variables/possible_const_state_variables.py @@ -76,7 +76,7 @@ class ConstCandidateStateVars(AbstractDetector): all_functions = [c.all_functions_called for c in self.slither.contracts] all_functions = list(set([item for sublist in all_functions for item in sublist])) - all_variables_written = [f.state_variables_written for f in all_functions] + all_variables_written = [f.state_variables_written for f in all_functions if not f.is_constructor_variables] all_variables_written = set([item for sublist in all_variables_written for item in sublist]) constable_variables = [v for v in all_non_constant_elementary_variables diff --git a/slither/solc_parsing/declarations/contract.py b/slither/solc_parsing/declarations/contract.py index f5fba278c..e931dddb7 100644 --- a/slither/solc_parsing/declarations/contract.py +++ b/slither/solc_parsing/declarations/contract.py @@ -377,7 +377,6 @@ class ContractSolc04(Contract): node.set_offset(variable.source_mapping, self.slither) node.set_function(func) func.add_node(node) - print(variable.expression) expression = AssignmentOperation(Identifier(variable), variable.expression, AssignmentOperationType.ASSIGN, diff --git a/tests/expected_json/deprecated_calls.deprecated-standards.json b/tests/expected_json/deprecated_calls.deprecated-standards.json index c25d611b8..2b9c385d1 100644 --- a/tests/expected_json/deprecated_calls.deprecated-standards.json +++ b/tests/expected_json/deprecated_calls.deprecated-standards.json @@ -692,6 +692,86 @@ } } ] + }, + { + "check": "deprecated-standards", + "impact": "Informational", + "confidence": "High", + "description": "Deprecated standard detected @ tests/deprecated_calls.sol#2:\n\t- Usage of \"block.blockhash()\" should be replaced with \"blockhash()\"\n", + "elements": [ + { + "type": "node", + "name": "globalBlockHash = block.blockhash(0)", + "source_mapping": { + "start": 48, + "length": 44, + "filename_used": "/home/travis/build/crytic/slither/tests/deprecated_calls.sol", + "filename_relative": "tests/deprecated_calls.sol", + "filename_absolute": "/home/travis/build/crytic/slither/tests/deprecated_calls.sol", + "filename_short": "tests/deprecated_calls.sol", + "is_dependency": false, + "lines": [ + 2 + ], + "starting_column": 5, + "ending_column": 49 + }, + "type_specific_fields": { + "parent": { + "type": "function", + "name": "slitherConstructorVariables", + "source_mapping": null, + "type_specific_fields": { + "parent": { + "type": "contract", + "name": "ContractWithDeprecatedReferences", + "source_mapping": { + "start": 0, + "length": 906, + "filename_used": "/home/travis/build/crytic/slither/tests/deprecated_calls.sol", + "filename_relative": "tests/deprecated_calls.sol", + "filename_absolute": "/home/travis/build/crytic/slither/tests/deprecated_calls.sol", + "filename_short": "tests/deprecated_calls.sol", + "is_dependency": false, + "lines": [ + 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 + ], + "starting_column": 1, + "ending_column": null + } + }, + "signature": "slitherConstructorVariables()" + } + } + } + } + ] } ] } diff --git a/tests/expected_json/deprecated_calls.deprecated-standards.txt b/tests/expected_json/deprecated_calls.deprecated-standards.txt index 7056ea4ce..63d07a08d 100644 --- a/tests/expected_json/deprecated_calls.deprecated-standards.txt +++ b/tests/expected_json/deprecated_calls.deprecated-standards.txt @@ -13,5 +13,7 @@ Deprecated standard detected @ tests/deprecated_calls.sol#22: - Usage of "callcode" should be replaced with "delegatecall" Deprecated standard detected @ tests/deprecated_calls.sol#25: - Usage of "suicide()" should be replaced with "selfdestruct()" +Deprecated standard detected @ tests/deprecated_calls.sol#2: + - Usage of "block.blockhash()" should be replaced with "blockhash()" Reference: https://github.com/crytic/slither/wiki/Detector-Documentation#deprecated-standards -INFO:Slither:tests/deprecated_calls.sol analyzed (1 contracts), 7 result(s) found +INFO:Slither:tests/deprecated_calls.sol analyzed (1 contracts), 8 result(s) found diff --git a/utils/similarity/encode.py b/utils/similarity/encode.py index f20d316a8..06b3691ed 100644 --- a/utils/similarity/encode.py +++ b/utils/similarity/encode.py @@ -195,7 +195,7 @@ def encode_contract(cfilename, **kwargs): # Iterate over all the functions for function in contract.functions_declared: - if function.nodes == []: + if function.nodes == [] or function.is_constructor_variables: continue x = (cfilename,contract.name,function.name) From 3fff0bf5b286cdf5d3802fdf7439f26f972a9356 Mon Sep 17 00:00:00 2001 From: Josselin Date: Fri, 5 Jul 2019 15:34:59 +0200 Subject: [PATCH 097/223] Upadte etherscan travis test --- scripts/travis_test_etherscan.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scripts/travis_test_etherscan.sh b/scripts/travis_test_etherscan.sh index c96eca12e..68b03f89f 100755 --- a/scripts/travis_test_etherscan.sh +++ b/scripts/travis_test_etherscan.sh @@ -18,7 +18,7 @@ fi slither rinkeby:0xFe05820C5A92D9bc906D4A46F662dbeba794d3b7 --solc "./solc-0.4.25" -if [ $? -ne 76 ] +if [ $? -ne 75 ] then echo "Etherscan test failed" exit -1 From 4c6ee59e42ee308786b809d5fdb69356fdf882ba Mon Sep 17 00:00:00 2001 From: Josselin Date: Fri, 5 Jul 2019 18:01:25 +0200 Subject: [PATCH 098/223] Improve overall source mapping support --- slither/slithir/convert.py | 9 +++-- .../expressions/expression_parsing.py | 38 ++++++++++++++----- .../visitors/slithir/expression_to_slithir.py | 5 ++- .../formatters/naming_convention.py | 29 ++++++++------ 4 files changed, 55 insertions(+), 26 deletions(-) diff --git a/slither/slithir/convert.py b/slither/slithir/convert.py index dbcef0159..975280cfd 100644 --- a/slither/slithir/convert.py +++ b/slither/slithir/convert.py @@ -556,10 +556,10 @@ def extract_tmp_call(ins, contract): internalcall.call_id = ins.call_id return internalcall if str(ins.ori.variable_right) in [f.name for f in contract.events]: - eventcall = EventCall(ins.ori.variable_right) - eventcall.set_expression(ins.expression) - eventcall.call_id = ins.call_id - return eventcall + eventcall = EventCall(ins.ori.variable_right) + eventcall.set_expression(ins.expression) + eventcall.call_id = ins.call_id + return eventcall if isinstance(ins.ori.variable_left, Contract): st = ins.ori.variable_left.get_structure_from_name(ins.ori.variable_right) if st: @@ -624,6 +624,7 @@ def extract_tmp_call(ins, contract): internalcall = InternalCall(ins.called.constructor, ins.nbr_arguments, ins.lvalue, ins.type_call) internalcall.call_id = ins.call_id + internalcall.set_expression(ins.expression) return internalcall diff --git a/slither/solc_parsing/expressions/expression_parsing.py b/slither/solc_parsing/expressions/expression_parsing.py index 5055c886f..0d95dbb6e 100644 --- a/slither/solc_parsing/expressions/expression_parsing.py +++ b/slither/solc_parsing/expressions/expression_parsing.py @@ -297,8 +297,9 @@ def parse_call(expression, caller_context): 'IndexAccess', 'MemberAccess'] - expression = parse_expression(expression_to_parse, caller_context) - t = TypeConversion(expression, type_call) + expression_parsed = parse_expression(expression_to_parse, caller_context) + t = TypeConversion(expression_parsed, type_call) + t.set_offset(expression['src'], caller_context.slither) return t if caller_context.is_compact_ast: @@ -312,7 +313,9 @@ def parse_call(expression, caller_context): arguments = [parse_expression(a, caller_context) for a in children[1::]] if isinstance(called, SuperCallExpression): - return SuperCallExpression(called, arguments, type_return) + sp = SuperCallExpression(called, arguments, type_return) + sp.set_offset(expression['src'], caller_context.slither) + return sp call_expression = CallExpression(called, arguments, type_return) call_expression.set_offset(expression['src'], caller_context.slither) return call_expression @@ -349,7 +352,9 @@ def _parse_elementary_type_name_expression(expression, is_compact_ast, caller_co value = expression['attributes']['value'] t = parse_type(UnknownType(value), caller_context) - return ElementaryTypeNameExpression(t) + e = ElementaryTypeNameExpression(t) + e.set_offset(expression['src'], caller_context.slither) + return e def parse_expression(expression, caller_context): """ @@ -393,11 +398,12 @@ def parse_expression(expression, caller_context): operation_type = UnaryOperationType.get_type(attributes['operator'], attributes['prefix']) if is_compact_ast: - expression = parse_expression(expression['subExpression'], caller_context) + expression_parsed = parse_expression(expression['subExpression'], caller_context) else: assert len(expression['children']) == 1 - expression = parse_expression(expression['children'][0], caller_context) - unary_op = UnaryOperation(expression, operation_type) + expression_parsed = parse_expression(expression['children'][0], caller_context) + unary_op = UnaryOperation(expression_parsed, operation_type) + unary_op.set_offset(expression['src'], caller_context.slither) return unary_op elif name == 'BinaryOperation': @@ -415,10 +421,11 @@ def parse_expression(expression, caller_context): left_expression = parse_expression(expression['children'][0], caller_context) right_expression = parse_expression(expression['children'][1], caller_context) binary_op = BinaryOperation(left_expression, right_expression, operation_type) + binary_op.set_offset(expression['src'], caller_context.slither) return binary_op elif name == 'FunctionCall': - return parse_call(expression, caller_context) + return parse_call(expression, caller_context) elif name == 'TupleExpression': """ @@ -433,7 +440,7 @@ def parse_expression(expression, caller_context): Note: this is only possible with Solidity >= 0.4.12 """ if is_compact_ast: - expressions = [parse_expression(e, caller_context) if e else None for e in expression['components']] + expressions = [parse_expression(e, caller_context) if e else None for e in expression['components']] else: if 'children' not in expression : attributes = expression['attributes'] @@ -452,6 +459,7 @@ def parse_expression(expression, caller_context): if elems[idx] == '': expressions.insert(idx, None) t = TupleExpression(expressions) + t.set_offset(expression['src'], caller_context.slither) return t elif name == 'Conditional': @@ -466,6 +474,7 @@ def parse_expression(expression, caller_context): then_expression = parse_expression(children[1], caller_context) else_expression = parse_expression(children[2], caller_context) conditional = ConditionalExpression(if_expression, then_expression, else_expression) + conditional.set_offset(expression['src'], caller_context.slither) return conditional elif name == 'Assignment': @@ -487,6 +496,7 @@ def parse_expression(expression, caller_context): operation_return_type = attributes['type'] assignement = AssignmentOperation(left_expression, right_expression, operation_type, operation_return_type) + assignement.set_offset(expression['src'], caller_context.slither) return assignement elif name == 'Literal': @@ -531,6 +541,7 @@ def parse_expression(expression, caller_context): else: type = ElementaryType('string') literal = Literal(value, type) + literal.set_offset(expression['src'], caller_context.slither) return literal elif name == 'Identifier': @@ -584,6 +595,7 @@ def parse_expression(expression, caller_context): left_expression = parse_expression(left, caller_context) right_expression = parse_expression(right, caller_context) index = IndexAccess(left_expression, right_expression, index_type) + index.set_offset(expression['src'], caller_context.slither) return index elif name == 'MemberAccess': @@ -604,8 +616,11 @@ def parse_expression(expression, caller_context): raise VariableNotFound('Variable not found: {}'.format(super_name)) return SuperIdentifier(var) member_access = MemberAccess(member_name, member_type, member_expression) + member_access.set_offset(expression['src'], caller_context.slither) if str(member_access) in SOLIDITY_VARIABLES_COMPOSED: - return Identifier(SolidityVariableComposed(str(member_access))) + identifier = Identifier(SolidityVariableComposed(str(member_access))) + identifier.set_offset(expression['src'], caller_context.slither) + return identifier return member_access elif name == 'ElementaryTypeNameExpression': @@ -647,6 +662,7 @@ def parse_expression(expression, caller_context): else: raise ParsingError('Incorrect type array {}'.format(type_name)) array = NewArray(depth, array_type) + array.set_offset(expression['src'], caller_context.slither) return array if type_name[caller_context.get_key()] == 'ElementaryTypeName': @@ -655,6 +671,7 @@ def parse_expression(expression, caller_context): else: elem_type = ElementaryType(type_name['attributes']['name']) new_elem = NewElementaryType(elem_type) + new_elem.set_offset(expression['src'], caller_context.slither) return new_elem assert type_name[caller_context.get_key()] == 'UserDefinedTypeName' @@ -664,6 +681,7 @@ def parse_expression(expression, caller_context): else: contract_name = type_name['attributes']['name'] new = NewContract(contract_name) + new.set_offset(expression['src'], caller_context.slither) return new elif name == 'ModifierInvocation': diff --git a/slither/visitors/slithir/expression_to_slithir.py b/slither/visitors/slithir/expression_to_slithir.py index 90a087a22..48919d09a 100644 --- a/slither/visitors/slithir/expression_to_slithir.py +++ b/slither/visitors/slithir/expression_to_slithir.py @@ -67,7 +67,9 @@ class ExpressionToSlithIR(ExpressionVisitor): self._result = [] self._visit_expression(self.expression) if node.type == NodeType.RETURN: - self._result.append(Return(get(self.expression))) + r = Return(get(self.expression)) + r.set_expression(expression) + self._result.append(r) for ir in self._result: ir.set_node(node) @@ -125,6 +127,7 @@ class ExpressionToSlithIR(ExpressionVisitor): args = [get(a) for a in expression.arguments if a] for arg in args: arg_ = Argument(arg) + arg_.set_expression(expression) self._result.append(arg_) if isinstance(called, Function): # internal call diff --git a/utils/slither_format/formatters/naming_convention.py b/utils/slither_format/formatters/naming_convention.py index 30ae27ad7..df0b11f54 100644 --- a/utils/slither_format/formatters/naming_convention.py +++ b/utils/slither_format/formatters/naming_convention.py @@ -410,21 +410,28 @@ def _explore_irs(slither, irs, result, target, convert): if not str(target) in full_txt: raise FormatError(f'{target} not found in {full_txt} ({source_mapping}') - if full_txt.count(str(target)) > 1: - raise FormatError(f'{target} found multiple times in {full_txt} ({source_mapping}') - old_str = str(target) new_str = convert(old_str) - loc_start = full_txt_start + full_txt.find(str(target)) - loc_end = loc_start + len(old_str) + counter = 0 + # Can be found multiple time on the same IR + # We patch one by one + while old_str in full_txt: - create_patch(result, - filename_source_code, - loc_start, - loc_end, - old_str, - new_str) + target_found_at = full_txt.find((old_str)) + + full_txt = full_txt[target_found_at+1:] + counter += target_found_at + + loc_start = full_txt_start + counter + loc_end = loc_start + len(old_str) + + create_patch(result, + filename_source_code, + loc_start, + loc_end, + old_str, + new_str) def _explore_functions(slither, functions, result, target, convert): From adacf35efd964d5bbfc7edb08389828f38298078 Mon Sep 17 00:00:00 2001 From: Josselin Date: Fri, 5 Jul 2019 18:16:26 +0200 Subject: [PATCH 099/223] slither-format Fix and improve patch dispatcher --- .../formatters/naming_convention.py | 47 ++++--------------- 1 file changed, 10 insertions(+), 37 deletions(-) diff --git a/utils/slither_format/formatters/naming_convention.py b/utils/slither_format/formatters/naming_convention.py index df0b11f54..a51e802ee 100644 --- a/utils/slither_format/formatters/naming_convention.py +++ b/utils/slither_format/formatters/naming_convention.py @@ -69,27 +69,10 @@ conventions ={ ################################################################################### ################################################################################### -def _unpack_info(slither, element): - path = element['source_mapping']['filename_absolute'] - source_code = slither.source_code[path].encode('utf-8') - - loc_start = element['source_mapping']['start'] - loc_end = loc_start + element['source_mapping']['length'] - old_string = source_code[loc_start:loc_end] - return path, source_code, old_string, loc_start, loc_end - -def get_name(element): - return element['name'] - -def get_contract_name(element): - target = element['additional_fields']['target'] - if target == "parameter": - return element['type_specific_fields']['parent']['type_specific_fields']['parent']['name'] - elif target in ["modifier", "function", "event", - "variable", "variable_constant", "enum", - "structure"]: - return element['type_specific_fields']['parent']['name'] - return element['name'] +def _get_from_contract(slither, element, name, getter): + contract_name = element['type_specific_fields']['parent']['name'] + contract = slither.get_contract_from_name(contract_name) + return getattr(contract, getter)(name) # endregion @@ -105,24 +88,20 @@ def _patch(slither, result, element, _target): target = slither.get_contract_from_name(element['name']) elif _target == "structure": - target = slither.get_structure_from_name(element['name']) + target = _get_from_contract(slither, element, element['name'], 'get_structure_from_name') elif _target == "event": - target = slither.get_event_from_name(element['name']) + target = _get_from_contract(slither, element, element['name'], 'get_event_from_name') elif _target == "function": # Avoid constructor (FP?) if element['name'] != element['type_specific_fields']['parent']['name']: - contract_name = element['type_specific_fields']['parent']['name'] function_sig = element['type_specific_fields']['signature'] - contract = slither.get_contract_from_name(contract_name) - target = contract.get_function_from_signature(function_sig) + target = _get_from_contract(slither, element, function_sig, 'get_function_from_signature') elif _target == "modifier": - contract_name = element['type_specific_fields']['parent']['name'] modifier_sig = element['type_specific_fields']['signature'] - contract = slither.get_contract_from_name(contract_name) - target = contract.get_modifier_from_signature(modifier_sig) + target = _get_from_contract(slither, element, modifier_sig, 'get_modifier_from_signature') elif _target == "parameter": contract_name = element['type_specific_fields']['parent']['type_specific_fields']['parent']['name'] @@ -143,16 +122,10 @@ def _patch(slither, result, element, _target): target = function.get_local_variable_from_name(var_name) # State variable else: - contract_name = element['type_specific_fields']['parent']['name'] - var_name = element['name'] - contract = slither.get_contract_from_name(contract_name) - target = contract.get_state_variable_from_name(var_name) + target = _get_from_contract(slither, element, element['name'], 'get_state_variable_from_name') elif _target == "enum": - contract_name = element['type_specific_fields']['parent']['name'] - enum_name = element['name'] - contract = slither.get_contract_from_name(contract_name) - target = contract.get_enum_from_canonical_name(enum_name) + target = _get_from_contract(slither, element, element['name'], 'get_enum_from_canonical_name') else: raise FormatError("Unknown naming convention! " + _target) From 6599ae69e61f7bb1e614ddd96b5ccf97f33cf21a Mon Sep 17 00:00:00 2001 From: Josselin Date: Fri, 5 Jul 2019 18:27:23 +0200 Subject: [PATCH 100/223] Minor --- utils/slither_format/formatters/naming_convention.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/utils/slither_format/formatters/naming_convention.py b/utils/slither_format/formatters/naming_convention.py index a51e802ee..d568f4e78 100644 --- a/utils/slither_format/formatters/naming_convention.py +++ b/utils/slither_format/formatters/naming_convention.py @@ -303,7 +303,7 @@ def _explore_modifiers_calls(slither, function, result, target, convert): def _explore_structures_declaration(slither, structures, result, target, convert): for st in structures: # Explore the variable declared within the structure (VariableStructure) - _explore_variables_declaration(slither, st.elem.values(), result, target, convert) + _explore_variables_declaration(slither, st.elems.values(), result, target, convert) # If the structure is the target if st == target: From af5bfa65b8b3c27f249e0463b5c84ce53c408a82 Mon Sep 17 00:00:00 2001 From: Josselin Date: Fri, 5 Jul 2019 19:12:44 +0200 Subject: [PATCH 101/223] Improve patches generation --- utils/slither_format/formatters/naming_convention.py | 2 +- utils/slither_format/slither_format.py | 12 +++++++++--- utils/slither_format/utils/patches.py | 11 +++++++---- 3 files changed, 17 insertions(+), 8 deletions(-) diff --git a/utils/slither_format/formatters/naming_convention.py b/utils/slither_format/formatters/naming_convention.py index d568f4e78..323732142 100644 --- a/utils/slither_format/formatters/naming_convention.py +++ b/utils/slither_format/formatters/naming_convention.py @@ -409,7 +409,7 @@ def _explore_irs(slither, irs, result, target, convert): def _explore_functions(slither, functions, result, target, convert): for function in functions: - _explore_variables_declaration(slither, function.local_variables, result, target, convert) + _explore_variables_declaration(slither, function.variables, result, target, convert) _explore_modifiers_calls(slither, function, result, target, convert) _explore_irs(slither, function.all_slithir_operations(), result, target, convert) diff --git a/utils/slither_format/slither_format.py b/utils/slither_format/slither_format.py index 458649579..1e024e774 100644 --- a/utils/slither_format/slither_format.py +++ b/utils/slither_format/slither_format.py @@ -59,14 +59,20 @@ def slither_format(slither, **kwargs): for file in result['patches']: original_txt = slither.source_code[file] patched_txt = original_txt - for patch in result['patches'][file]: - patched_txt = apply_patch(patched_txt, patch) + offset = 0 + patches = result['patches'][file] + patches.sort(key=lambda x:x['start']) + if not all(patches[i]['end'] <= patches[i+1]['end'] for i in range(len(patches)-1)): + logger.info(f'Impossible to generate patch; patches collisions: {patches}') + continue + for patch in patches: + patched_txt, offset = apply_patch(patched_txt, patch, offset) diff = create_diff(slither, original_txt, patched_txt, file) result['paches_diff'] = diff if skip_file_generation: continue if not diff: - logger.info(f'Empty patch generated {result}') + logger.info(f'Impossible to generate patch; empty {result}') continue path = os.path.join(export, f'fix_{counter}.patch') logger.info(f'\t- {path}') diff --git a/utils/slither_format/utils/patches.py b/utils/slither_format/utils/patches.py index cf4bacb72..a8fb48d11 100644 --- a/utils/slither_format/utils/patches.py +++ b/utils/slither_format/utils/patches.py @@ -14,11 +14,14 @@ def create_patch(result, file, start, end, old_str, new_str): result['patches'][file].append(p) -def apply_patch(original_txt, patch): - patched_txt = original_txt[:int(patch['start'])] +def apply_patch(original_txt, patch, offset): + patched_txt = original_txt[:int(patch['start'] + offset)] patched_txt += patch['new_string'] - patched_txt += original_txt[int(patch['end']):] - return patched_txt + patched_txt += original_txt[int(patch['end'] + offset):] + + # Keep the diff of text added or sub, in case of multiple patches + patch_length_diff = len(patch['new_string']) - (patch['end'] - patch['start']) + return patched_txt, patch_length_diff + offset def create_diff(slither, original_txt, patched_txt, filename): From 74ae4a9e5f9de96c19aad87e7a8376dbda39d86a Mon Sep 17 00:00:00 2001 From: Josselin Date: Fri, 5 Jul 2019 19:33:52 +0200 Subject: [PATCH 102/223] Prevent collision with existing name --- .../formatters/naming_convention.py | 59 +++++++++++++------ 1 file changed, 42 insertions(+), 17 deletions(-) diff --git a/utils/slither_format/formatters/naming_convention.py b/utils/slither_format/formatters/naming_convention.py index 323732142..94b6197af 100644 --- a/utils/slither_format/formatters/naming_convention.py +++ b/utils/slither_format/formatters/naming_convention.py @@ -5,7 +5,7 @@ from slither.slithir.operations import Send, Transfer, OperationWithLValue, High from slither.core.declarations import Modifier from slither.core.solidity_types import UserDefinedType, MappingType from slither.core.declarations import Enum, Contract, Structure -from ..exceptions import FormatError +from ..exceptions import FormatError, FormatImpossible from ..utils.patches import create_patch logging.basicConfig(level=logging.INFO) @@ -32,27 +32,53 @@ def format(slither, result): ################################################################################### ################################################################################### -def _convert_CapWords(name): - name = name.capitalize() + +KEY = 'ALL_NAMES_USED' + +def _name_already_use(slither, name): + # Do not convert to a name used somewhere else + if not KEY in slither.context: + all_names = set() + for contract in slither.contracts_derived: + all_names = all_names.union(set([st.name for st in contract.structures])) + all_names = all_names.union(set([f.name for f in contract.functions_and_modifiers])) + all_names = all_names.union(set([e.name for e in contract.enums])) + all_names = all_names.union(set([s.name for s in contract.state_variables])) + + for function in contract.functions: + all_names = all_names.union(set([v.name for v in function.variables])) + + slither.context[KEY] = all_names + return name in slither.context[KEY] + +def _convert_CapWords(original_name, slither): + name = original_name.capitalize() while '_' in name: offset = name.find('_') if len(name) > offset: name = name[0:offset] + name[offset+1].upper() + name[offset+1:] + if _name_already_use(slither, name): + raise FormatImpossible(f'{original_name} cannot be converted to {name} (already used)') return name -def _convert_mixedCase(name): +def _convert_mixedCase(original_name, slither): + name = original_name while '_' in name: offset = name.find('_') if len(name) > offset: name = name[0:offset] + name[offset + 1].upper() + name[offset + 2:] name = name[0].lower() + name[1:] + if _name_already_use(slither, name): + raise FormatImpossible(f'{original_name} cannot be converted to {name} (already used)') return name -def _convert_UPPER_CASE_WITH_UNDERSCORES(name): +def _convert_UPPER_CASE_WITH_UNDERSCORES(name, slither): + if _name_already_use(slither, name.upper()): + raise FormatImpossible(f'{name} cannot be converted to {name.upper()} (already used)') return name.upper() conventions ={ @@ -74,7 +100,6 @@ def _get_from_contract(slither, element, name, getter): contract = slither.get_contract_from_name(contract_name) return getattr(contract, getter)(name) - # endregion ################################################################################### ################################################################################### @@ -157,7 +182,7 @@ def _explore_type(slither, result, target, convert, type, filename_source_code, if isinstance(type.type, (Enum, Contract)): if type.type == target: old_str = type.type.name - new_str = convert(old_str) + new_str = convert(old_str, slither) loc_start = start loc_end = loc_start + len(old_str) @@ -175,7 +200,7 @@ def _explore_type(slither, result, target, convert, type, filename_source_code, assert isinstance(type.type, Structure) if type.type == target: old_str = type.type.name - new_str = convert(old_str) + new_str = convert(old_str, slither) loc_start = start loc_end = loc_start + len(old_str) @@ -214,7 +239,7 @@ def _explore_type(slither, result, target, convert, type, filename_source_code, if type.type_from == target: old_str = type.type_from.name - new_str = convert(old_str) + new_str = convert(old_str, slither) loc_start = start + re_match.start(1) loc_end = loc_start + len(old_str) @@ -229,7 +254,7 @@ def _explore_type(slither, result, target, convert, type, filename_source_code, if type.type_to == target: old_str = type.type_to.name - new_str = convert(old_str) + new_str = convert(old_str, slither) loc_start = start + re_match.start(2) loc_end = loc_start + len(old_str) @@ -275,7 +300,7 @@ def _explore_variables_declaration(slither, variables, result, target, convert): # If the variable is the target if variable == target: old_str = variable.name - new_str = convert(old_str) + new_str = convert(old_str, slither) # The name is after the space # We take all the space, as we dont know the type @@ -308,7 +333,7 @@ def _explore_structures_declaration(slither, structures, result, target, convert # If the structure is the target if st == target: old_str = st.name - new_str = convert(old_str) + new_str = convert(old_str, slither) filename_source_code = st.source_mapping['filename_absolute'] full_txt_start = st.source_mapping['start'] @@ -339,7 +364,7 @@ def _explore_events_declaration(slither, events, result, target, convert): filename_source_code = event.source_mapping['filename_absolute'] old_str = event.name - new_str = convert(old_str) + new_str = convert(old_str, slither) loc_start = event.source_mapping['start'] loc_end = loc_start + len(old_str) @@ -384,7 +409,7 @@ def _explore_irs(slither, irs, result, target, convert): raise FormatError(f'{target} not found in {full_txt} ({source_mapping}') old_str = str(target) - new_str = convert(old_str) + new_str = convert(old_str, slither) counter = 0 # Can be found multiple time on the same IR @@ -415,7 +440,7 @@ def _explore_functions(slither, functions, result, target, convert): if function == target: old_str = function.name - new_str = convert(old_str) + new_str = convert(old_str, slither) filename_source_code = function.source_mapping['filename_absolute'] full_txt_start = function.source_mapping['start'] @@ -443,7 +468,7 @@ def _explore_enums(slither, enums, result, target, convert): if enum == target: print(target) old_str = enum.name - new_str = convert(old_str) + new_str = convert(old_str, slither) filename_source_code = enum.source_mapping['filename_absolute'] full_txt_start = enum.source_mapping['start'] @@ -477,7 +502,7 @@ def _explore_contract(slither, contract, result, target, convert): full_txt = slither.source_code[filename_source_code][full_txt_start:full_txt_end] old_str = contract.name - new_str = convert(old_str) + new_str = convert(old_str, slither) # The name is after the space matches = re.finditer('contract[ ]*', full_txt) From 66830b3362679c25000681d58df2a27542edb111 Mon Sep 17 00:00:00 2001 From: Josselin Date: Thu, 18 Jul 2019 09:17:58 +0200 Subject: [PATCH 103/223] Naming convention: allow _ in name for private/internal function + fix regex (fix #287) Solc parsing: dont translate to scope variable without name (SSA) --- slither/detectors/naming_convention/naming_convention.py | 4 +++- slither/solc_parsing/declarations/function.py | 7 ++++--- 2 files changed, 7 insertions(+), 4 deletions(-) diff --git a/slither/detectors/naming_convention/naming_convention.py b/slither/detectors/naming_convention/naming_convention.py index 9c69e41ba..6c72f4438 100644 --- a/slither/detectors/naming_convention/naming_convention.py +++ b/slither/detectors/naming_convention/naming_convention.py @@ -41,7 +41,7 @@ Solidity defines a [naming convention](https://solidity.readthedocs.io/en/v0.4.2 def is_mixed_case_with_underscore(name): # Allow _ at the beginning to represent private variable # or unused parameters - return re.search('^[a-z_]([A-Za-z0-9]+)?_?$', name) is not None + return re.search('^[_]?[a-z]([A-Za-z0-9]+)?_?$', name) is not None @staticmethod def is_upper_case_with_underscores(name): @@ -93,6 +93,8 @@ Solidity defines a [naming convention](https://solidity.readthedocs.io/en/v0.4.2 for func in contract.functions_declared: if not self.is_mixed_case(func.name): + if func.visibility in ['internal', 'private'] and self.is_mixed_case_with_underscore(func.name): + continue info = "Function '{}' ({}) is not in mixedCase\n" info = info.format(func.canonical_name, func.source_mapping_str) diff --git a/slither/solc_parsing/declarations/function.py b/slither/solc_parsing/declarations/function.py index 5c95cc231..bfe0d4ea2 100644 --- a/slither/solc_parsing/declarations/function.py +++ b/slither/solc_parsing/declarations/function.py @@ -98,9 +98,10 @@ class FunctionSolc(Function): # This is done to prevent collision during SSA translation # Use of while in case of collision # In the worst case, the name will be really long - while local_var.name in self._variables: - local_var.name += "_scope_{}".format(self._counter_scope_local_variables) - self._counter_scope_local_variables += 1 + if local_var.name: + while local_var.name in self._variables: + local_var.name += "_scope_{}".format(self._counter_scope_local_variables) + self._counter_scope_local_variables += 1 if not local_var.reference_id is None: self._variables_renamed[local_var.reference_id] = local_var self._variables[local_var.name] = local_var From 6ebc8bb35e2d7edd259c0f0f1aaaa65447dcc778 Mon Sep 17 00:00:00 2001 From: Josselin Date: Fri, 19 Jul 2019 10:12:37 +0200 Subject: [PATCH 104/223] Add source mapping to constructor_variable --- slither/solc_parsing/declarations/contract.py | 38 ++++++++++--------- 1 file changed, 20 insertions(+), 18 deletions(-) diff --git a/slither/solc_parsing/declarations/contract.py b/slither/solc_parsing/declarations/contract.py index e931dddb7..c7a9a7793 100644 --- a/slither/solc_parsing/declarations/contract.py +++ b/slither/solc_parsing/declarations/contract.py @@ -387,27 +387,29 @@ class ContractSolc04(Contract): def add_constructor_variables(self): if self.state_variables: - found_candidate = False for (idx, variable_candidate) in enumerate(self.state_variables): if variable_candidate.expression and not variable_candidate.is_constant: - found_candidate = True + + constructor_variable = Function() + constructor_variable.set_function_type(FunctionType.CONSTRUCTOR_VARIABLES) + constructor_variable.set_contract(self) + constructor_variable.set_contract_declarer(self) + constructor_variable.set_visibility('internal') + # For now, source mapping of the constructor variable is the whole contract + # Could be improved with a targeted source mapping + constructor_variable.set_offset(self.source_mapping, self.slither) + self._functions[constructor_variable.canonical_name] = constructor_variable + + prev_node = self._create_node(constructor_variable, 0, variable_candidate) + counter = 1 + for v in self.state_variables[idx+1:]: + if v.expression and not v.is_constant: + next_node = self._create_node(constructor_variable, counter, v) + prev_node.add_son(next_node) + next_node.add_father(prev_node) + counter += 1 + break - if found_candidate: - constructor_variable = Function() - constructor_variable.set_function_type(FunctionType.CONSTRUCTOR_VARIABLES) - constructor_variable.set_contract(self) - constructor_variable.set_contract_declarer(self) - constructor_variable.set_visibility('internal') - self._functions[constructor_variable.canonical_name] = constructor_variable - - prev_node = self._create_node(constructor_variable, 0, variable_candidate) - counter = 1 - for v in self.state_variables[idx+1:]: - if v.expression and not v.is_constant: - next_node = self._create_node(constructor_variable, counter, v) - prev_node.add_son(next_node) - next_node.add_father(prev_node) - counter += 1 From ccfdfd7dbb7bfa4b382a26746a10f23c0c7752a0 Mon Sep 17 00:00:00 2001 From: Feist Josselin Date: Mon, 22 Jul 2019 21:36:47 +0200 Subject: [PATCH 105/223] Update README.md --- README.md | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 5d0ff6c85..55e55d9c4 100644 --- a/README.md +++ b/README.md @@ -112,8 +112,13 @@ $ pip install slither-analyzer ### Using Git +Installing through git requires installing [crytic-compile](https://github.com/crytic/crytic-compile) from git too: + ```bash -$ git clone https://github.com/trailofbits/slither.git && cd slither +$ git clone https://github.com/crytic/crytic-compile.git && cd crytic-compile +$ python setup.py install +$ cd .. +$ git clone https://github.com/crytic/slither.git && cd slither $ python setup.py install ``` From 119ef0684d1eddd4222c2a05a0c51c66f134824f Mon Sep 17 00:00:00 2001 From: Josselin Date: Tue, 23 Jul 2019 09:57:02 +0200 Subject: [PATCH 106/223] rename detectors-types to list-detectors add list-printers --- slither/__main__.py | 19 ++++++++++++------- slither/utils/command_line.py | 24 +++++++++++++++++++++++- 2 files changed, 35 insertions(+), 8 deletions(-) diff --git a/slither/__main__.py b/slither/__main__.py index db5857276..96c9dc41a 100644 --- a/slither/__main__.py +++ b/slither/__main__.py @@ -22,16 +22,16 @@ from slither.slither import Slither from slither.utils.output_capture import StandardOutputCapture from slither.utils.colors import red, yellow, set_colorization_enabled from slither.utils.command_line import (output_detectors, output_results_to_markdown, - get_detector_types_json, output_printers, - output_to_markdown, output_wiki) + output_detectors_json, output_printers, + output_to_markdown, output_wiki, output_printers_json) from crytic_compile import compile_all, is_supported from slither.exceptions import SlitherException logging.basicConfig() logger = logging.getLogger("Slither") -JSON_OUTPUT_TYPES = ["compilations", "console", "detectors", "detector-types"] -DEFAULT_JSON_OUTPUT_TYPES = ["console", "detectors", "detector-types"] +JSON_OUTPUT_TYPES = ["compilations", "console", "detectors", "list-detectors", "list-printers"] +DEFAULT_JSON_OUTPUT_TYPES = ["console", "detectors", "list-detectors", "list-printers"] ################################################################################### ################################################################################### @@ -480,7 +480,7 @@ class ListDetectors(argparse.Action): class ListDetectorsJson(argparse.Action): def __call__(self, parser, *args, **kwargs): detectors, _ = get_detectors_and_printers() - detector_types_json = get_detector_types_json(detectors) + detector_types_json = output_detectors_json(detectors) print(json.dumps(detector_types_json)) parser.exit() @@ -628,9 +628,14 @@ def main_impl(all_detector_classes, all_printer_classes): json_results['detectors'] = results # Add our detector types to JSON - if 'detector-types' in args.json_types: + if 'list-detectors' in args.json_types: detectors, _ = get_detectors_and_printers() - json_results['detector-types'] = get_detector_types_json(detectors) + json_results['list-detectors'] = output_detectors_json(detectors) + + # Add our detector types to JSON + if 'list-printers' in args.json_types: + _, printers = get_detectors_and_printers() + json_results['list-printers'] = output_printers_json(printers) # Output our results to markdown if we wish to compile a checklist. if args.checklist: diff --git a/slither/utils/command_line.py b/slither/utils/command_line.py index 531181c4a..ed4759038 100644 --- a/slither/utils/command_line.py +++ b/slither/utils/command_line.py @@ -156,7 +156,7 @@ def output_detectors(detector_classes): print(table) -def get_detector_types_json(detector_classes): +def output_detectors_json(detector_classes): detectors_list = [] for detector in detector_classes: argument = detector.ARGUMENT @@ -213,3 +213,25 @@ def output_printers(printer_classes): table.add_row([idx, argument, help_info]) idx = idx + 1 print(table) + + +def output_printers_json(printer_classes): + printers_list = [] + for printer in printer_classes: + argument = printer.ARGUMENT + help_info = printer.HELP + + printers_list.append((argument, + help_info)) + + # Sort by name + printers_list = sorted(printers_list, key=lambda element: (element[0])) + idx = 1 + table = [] + for (argument, help_info) in printers_list: + table.append({'index': idx, + 'check': argument, + 'title': help_info}) + idx = idx + 1 + return table + From 595e8b982862e7fa8f8580a2fd7aafc689d297a1 Mon Sep 17 00:00:00 2001 From: Josselin Date: Tue, 23 Jul 2019 10:13:26 +0200 Subject: [PATCH 107/223] Fix travis --- ...deprecated_calls.deprecated-standards.json | 41 ++++++++++++++++++- 1 file changed, 40 insertions(+), 1 deletion(-) diff --git a/tests/expected_json/deprecated_calls.deprecated-standards.json b/tests/expected_json/deprecated_calls.deprecated-standards.json index 2b9c385d1..9680b948d 100644 --- a/tests/expected_json/deprecated_calls.deprecated-standards.json +++ b/tests/expected_json/deprecated_calls.deprecated-standards.json @@ -720,7 +720,46 @@ "parent": { "type": "function", "name": "slitherConstructorVariables", - "source_mapping": null, + "source_mapping": { + "start": 0, + "length": 906, + "filename_used": "/home/travis/build/crytic/slither/tests/deprecated_calls.sol", + "filename_relative": "tests/deprecated_calls.sol", + "filename_absolute": "/home/travis/build/crytic/slither/tests/deprecated_calls.sol", + "filename_short": "tests/deprecated_calls.sol", + "is_dependency": false, + "lines": [ + 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 + ], + "starting_column": 1, + "ending_column": null + }, "type_specific_fields": { "parent": { "type": "contract", From 590b8b698c4c798669effd73fce3b74b19bf0f9b Mon Sep 17 00:00:00 2001 From: Josselin Date: Tue, 23 Jul 2019 10:14:54 +0200 Subject: [PATCH 108/223] Change default json to only output detectors --- slither/utils/command_line.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/slither/utils/command_line.py b/slither/utils/command_line.py index 5d0140be6..c83c5dbdf 100644 --- a/slither/utils/command_line.py +++ b/slither/utils/command_line.py @@ -10,7 +10,7 @@ from .colors import yellow, red logger = logging.getLogger("Slither") -DEFAULT_JSON_OUTPUT_TYPES = ["console", "detectors", "list-detectors", "list-printers"] +DEFAULT_JSON_OUTPUT_TYPES = ["detectors"] JSON_OUTPUT_TYPES = ["compilations", "console", "detectors", "list-detectors", "list-printers"] From 9d93e7bd9f732fcc2dbabd827cc3bdd4da418c6d Mon Sep 17 00:00:00 2001 From: Josselin Date: Wed, 24 Jul 2019 08:38:19 +0200 Subject: [PATCH 109/223] Add support for ternary operator in modifier/constructor calls Add NOP IR to represent void constructor Add void-constructor detector --- scripts/tests_generate_expected_json_4.sh | 2 +- scripts/tests_generate_expected_json_5.sh | 1 + scripts/travis_test_5.sh | 1 + slither/core/cfg/node.py | 19 ++- slither/core/declarations/function.py | 36 ++++- slither/detectors/all_detectors.py | 1 + .../detectors/operations/void_constructor.py | 46 +++++++ slither/printers/summary/slithir.py | 8 +- slither/slithir/convert.py | 5 +- slither/slithir/operations/__init__.py | 1 + slither/slithir/operations/nop.py | 14 ++ slither/solc_parsing/declarations/contract.py | 2 +- slither/solc_parsing/declarations/function.py | 35 +++-- .../visitors/slithir/expression_to_slithir.py | 2 +- tests/expected_json/void-cst.void-cst.json | 130 ++++++++++++++++++ tests/expected_json/void-cst.void-cst.txt | 5 + tests/void-cst.sol | 14 ++ 17 files changed, 294 insertions(+), 28 deletions(-) create mode 100644 slither/detectors/operations/void_constructor.py create mode 100644 slither/slithir/operations/nop.py create mode 100644 tests/expected_json/void-cst.void-cst.json create mode 100644 tests/expected_json/void-cst.void-cst.txt create mode 100644 tests/void-cst.sol diff --git a/scripts/tests_generate_expected_json_4.sh b/scripts/tests_generate_expected_json_4.sh index e748e4f42..4e1def80c 100755 --- a/scripts/tests_generate_expected_json_4.sh +++ b/scripts/tests_generate_expected_json_4.sh @@ -21,7 +21,7 @@ generate_expected_json(){ } -generate_expected_json tests/deprecated_calls.sol "deprecated-standards" +#generate_expected_json tests/deprecated_calls.sol "deprecated-standards" #generate_expected_json tests/erc20_indexed.sol "erc20-indexed" #generate_expected_json tests/incorrect_erc20_interface.sol "erc20-interface" #generate_expected_json tests/incorrect_erc721_interface.sol "erc721-interface" diff --git a/scripts/tests_generate_expected_json_5.sh b/scripts/tests_generate_expected_json_5.sh index fb9552437..78cc2b3ef 100755 --- a/scripts/tests_generate_expected_json_5.sh +++ b/scripts/tests_generate_expected_json_5.sh @@ -20,6 +20,7 @@ generate_expected_json(){ sed "s|$CURRENT_PATH|$TRAVIS_PATH|g" "$output_filename_txt" -i } +generate_expected_json tests/void-cst.sol "void-cst" #generate_expected_json tests/solc_version_incorrect_05.ast.json "solc-version" #generate_expected_json tests/uninitialized-0.5.1.sol "uninitialized-state" #generate_expected_json tests/backdoor.sol "backdoor" diff --git a/scripts/travis_test_5.sh b/scripts/travis_test_5.sh index 7224638d7..bb598ac1f 100755 --- a/scripts/travis_test_5.sh +++ b/scripts/travis_test_5.sh @@ -69,6 +69,7 @@ test_slither(){ } +test_slither tests/void-cst.json "void-cst" test_slither tests/solc_version_incorrect_05.ast.json "solc-version" test_slither tests/unchecked_lowlevel-0.5.1.sol "unchecked-lowlevel" test_slither tests/unchecked_send-0.5.1.sol "unchecked-send" diff --git a/slither/core/cfg/node.py b/slither/core/cfg/node.py index 8a94a7caa..4251b0bad 100644 --- a/slither/core/cfg/node.py +++ b/slither/core/cfg/node.py @@ -64,7 +64,7 @@ class NodeType: # Node not related to the CFG # Use for state variable declaration, or modifier calls - STANDALONE = 0x50 + OTHER_ENTRYPOINT = 0x50 # @staticmethod @@ -111,6 +111,23 @@ def link_nodes(n1, n2): n1.add_son(n2) n2.add_father(n1) +def recheable(node): + ''' + Return the set of nodes reacheable from the node + :param node: + :return: set(Node) + ''' + nodes = node.sons + visited = set() + while nodes: + next = nodes[0] + nodes = nodes[1:] + if not next in visited: + visited.add(next) + for son in next.sons: + if not son in visited: + nodes.append(son) + return visited # endregion diff --git a/slither/core/declarations/function.py b/slither/core/declarations/function.py index 7243a7c03..c0f5b2687 100644 --- a/slither/core/declarations/function.py +++ b/slither/core/declarations/function.py @@ -22,7 +22,33 @@ logger = logging.getLogger("Function") ReacheableNode = namedtuple('ReacheableNode', ['node', 'ir']) -ModifierStatements = namedtuple('Modifier', ['modifier', 'node']) +class ModifierStatements: + + def __init__(self, modifier, entry_point, nodes): + self._modifier = modifier + self._entry_point = entry_point + self._nodes = nodes + + + @property + def modifier(self): + return self._modifier + + @property + def entry_point(self): + return self._entry_point + + @entry_point.setter + def entry_point(self, entry_point): + self._entry_point = entry_point + + @property + def nodes(self): + return self._nodes + + @nodes.setter + def nodes(self, nodes): + self._nodes = nodes class FunctionType(Enum): NORMAL = 0 @@ -403,7 +429,7 @@ class Function(ChildContract, ChildInheritance, SourceMapping): """ # This is a list of contracts internally, so we convert it to a list of constructor functions. - return [c for c in self._explicit_base_constructor_calls if c.modifier.constructors_declared] + return list(self._explicit_base_constructor_calls) # endregion @@ -1266,10 +1292,12 @@ class Function(ChildContract, ChildInheritance, SourceMapping): node.slithir_generation() for modifier_statement in self.modifiers_statements: - modifier_statement.node.slithir_generation() + for node in modifier_statement.nodes: + node.slithir_generation() for modifier_statement in self.explicit_base_constructor_calls_statements: - modifier_statement.node.slithir_generation() + for node in modifier_statement.nodes: + node.slithir_generation() self._analyze_read_write() self._analyze_calls() diff --git a/slither/detectors/all_detectors.py b/slither/detectors/all_detectors.py index 9fd21ac83..39822221b 100644 --- a/slither/detectors/all_detectors.py +++ b/slither/detectors/all_detectors.py @@ -36,5 +36,6 @@ from .source.rtlo import RightToLeftOverride from .statements.too_many_digits import TooManyDigits from .operations.unchecked_low_level_return_values import UncheckedLowLevel from .operations.unchecked_send_return_value import UncheckedSend +from .operations.void_constructor import VoidConstructor # # diff --git a/slither/detectors/operations/void_constructor.py b/slither/detectors/operations/void_constructor.py new file mode 100644 index 000000000..6f2097e75 --- /dev/null +++ b/slither/detectors/operations/void_constructor.py @@ -0,0 +1,46 @@ + +from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification +from slither.slithir.operations import Nop + +class VoidConstructor(AbstractDetector): + + ARGUMENT = 'void-cst' + HELP = 'Constructor called not implemented' + IMPACT = DetectorClassification.LOW + CONFIDENCE = DetectorClassification.HIGH + + WIKI = 'https://github.com/crytic/slither/wiki/Detector-Documentation#void-constructor' + + WIKI_TITLE = 'Void Constructor' + WIKI_DESCRIPTION = 'Detect the call to a constructor not implemented' + WIKI_RECOMMENDATION = 'Remove the constructor call.' + WIKI_EXPLOIT_SCENARIO = ''' + ```solidity +contract A{} +contract B is A{ + constructor() public A(){} +} +``` +By reading B's constructor definition, the reader might assume that `A()` initiate the contract, while no code is executed.''' + + + def _detect(self): + """ + """ + results = [] + for c in self.contracts: + cst = c.constructor + if cst: + + for constructor_call in cst.explicit_base_constructor_calls_statements: + for node in constructor_call.nodes: + if any(isinstance(ir, Nop) for ir in node.irs): + info = "Void constructor called in {} ({}):\n" + info = info.format(cst.canonical_name, cst.source_mapping_str) + info += "\t-{} {}\n".format(str(node.expression), node.source_mapping_str) + + json = self.generate_json_result(info) + self.add_function_to_json(cst, json) + self.add_nodes_to_json([node], json) + results.append(json) + return results diff --git a/slither/printers/summary/slithir.py b/slither/printers/summary/slithir.py index c6e30073f..4e936e038 100644 --- a/slither/printers/summary/slithir.py +++ b/slither/printers/summary/slithir.py @@ -35,13 +35,9 @@ class PrinterSlithIR(AbstractPrinter): for ir in node.irs: print('\t\t\t{}'.format(ir)) for modifier_statement in function.modifiers_statements: - print(f'\t\tModifier Call {modifier_statement.node.expression}') - for ir in modifier_statement.node.irs: - print('\t\t\t{}'.format(ir)) + print(f'\t\tModifier Call {modifier_statement.entry_point.expression}') for modifier_statement in function.explicit_base_constructor_calls_statements: - print(f'\t\tConstructor Call {modifier_statement.node.expression}') - for ir in modifier_statement.node.irs: - print('\t\t\t{}'.format(ir)) + print(f'\t\tConstructor Call {modifier_statement.entry_point.expression}') for modifier in contract.modifiers: print('\tModifier {}'.format(modifier.canonical_name)) for node in modifier.nodes: diff --git a/slither/slithir/convert.py b/slither/slithir/convert.py index 101604d55..c50a4f8a6 100644 --- a/slither/slithir/convert.py +++ b/slither/slithir/convert.py @@ -21,7 +21,7 @@ from slither.slithir.operations import (Assignment, Balance, Binary, NewElementaryType, NewStructure, OperationWithLValue, Push, Return, Send, SolidityCall, Transfer, - TypeConversion, Unary, Unpack) + TypeConversion, Unary, Unpack, Nop) from slither.slithir.tmp_operations.argument import Argument, ArgumentType from slither.slithir.tmp_operations.tmp_call import TmpCall from slither.slithir.tmp_operations.tmp_new_array import TmpNewArray @@ -587,6 +587,9 @@ def extract_tmp_call(ins, contract): return EventCall(ins.called.name) if isinstance(ins.called, Contract): + # Called a base constructor, where there is no constructor + if ins.called.constructor is None: + return Nop() internalcall = InternalCall(ins.called.constructor, ins.nbr_arguments, ins.lvalue, ins.type_call) internalcall.call_id = ins.call_id diff --git a/slither/slithir/operations/__init__.py b/slither/slithir/operations/__init__.py index b20df950d..cccc812e5 100644 --- a/slither/slithir/operations/__init__.py +++ b/slither/slithir/operations/__init__.py @@ -30,3 +30,4 @@ from .length import Length from .balance import Balance from .phi import Phi from .phi_callback import PhiCallback +from .nop import Nop diff --git a/slither/slithir/operations/nop.py b/slither/slithir/operations/nop.py new file mode 100644 index 000000000..fb26813c1 --- /dev/null +++ b/slither/slithir/operations/nop.py @@ -0,0 +1,14 @@ +from .operation import Operation + +class Nop(Operation): + + @property + def read(self): + return [] + + @property + def used(self): + return [] + + def __str__(self): + return "NOP" \ No newline at end of file diff --git a/slither/solc_parsing/declarations/contract.py b/slither/solc_parsing/declarations/contract.py index c7a9a7793..eb6021966 100644 --- a/slither/solc_parsing/declarations/contract.py +++ b/slither/solc_parsing/declarations/contract.py @@ -373,7 +373,7 @@ class ContractSolc04(Contract): def _create_node(self, func, counter, variable): # Function uses to create node for state variable declaration statements - node = Node(NodeType.STANDALONE, counter) + node = Node(NodeType.OTHER_ENTRYPOINT, counter) node.set_offset(variable.source_mapping, self.slither) node.set_function(func) func.add_node(node) diff --git a/slither/solc_parsing/declarations/function.py b/slither/solc_parsing/declarations/function.py index bfe0d4ea2..9ec13cef8 100644 --- a/slither/solc_parsing/declarations/function.py +++ b/slither/solc_parsing/declarations/function.py @@ -2,7 +2,7 @@ """ import logging -from slither.core.cfg.node import NodeType, link_nodes +from slither.core.cfg.node import NodeType, link_nodes, recheable from slither.core.declarations.contract import Contract from slither.core.declarations.function import Function, ModifierStatements, FunctionType @@ -220,13 +220,13 @@ class FunctionSolc(Function): for node in self.nodes: node.analyze_expressions(self) - for modifier_statement in self.modifiers_statements: - modifier_statement.node.analyze_expressions(self) + if self._filter_ternary(): + for modifier_statement in self.modifiers_statements: + modifier_statement.nodes = recheable(modifier_statement.entry_point) - for modifier_statement in self.explicit_base_constructor_calls_statements: - modifier_statement.node.analyze_expressions(self) + for modifier_statement in self.explicit_base_constructor_calls_statements: + modifier_statement.nodes = recheable(modifier_statement.entry_point) - self._filter_ternary() self._remove_alone_endif() @@ -903,15 +903,21 @@ class FunctionSolc(Function): self._expression_modifiers.append(m) for m in ExportValues(m).result(): if isinstance(m, Function): - node = self._new_node(NodeType.STANDALONE, modifier['src']) + entry_point = self._new_node(NodeType.OTHER_ENTRYPOINT, modifier['src']) + node = self._new_node(NodeType.EXPRESSION, modifier['src']) node.add_unparsed_expression(modifier) + link_nodes(entry_point, node) self._modifiers.append(ModifierStatements(modifier=m, - node=node)) + entry_point=entry_point, + nodes=[entry_point, node])) elif isinstance(m, Contract): - node = self._new_node(NodeType.STANDALONE, modifier['src']) + entry_point = self._new_node(NodeType.OTHER_ENTRYPOINT, modifier['src']) + node = self._new_node(NodeType.EXPRESSION, modifier['src']) node.add_unparsed_expression(modifier) + link_nodes(entry_point, node) self._explicit_base_constructor_calls.append(ModifierStatements(modifier=m, - node=node)) + entry_point=entry_point, + nodes=[entry_point, node])) # endregion ################################################################################### @@ -971,9 +977,10 @@ class FunctionSolc(Function): def _filter_ternary(self): ternary_found = True + updated = False while ternary_found: ternary_found = False - for node in self.nodes: + for node in self._nodes: has_cond = HasConditional(node.expression) if has_cond.result(): st = SplitTernaryExpression(node.expression) @@ -982,11 +989,13 @@ class FunctionSolc(Function): raise ParsingError(f'Incorrect ternary conversion {node.expression} {node.source_mapping_str}') true_expr = st.true_expression false_expr = st.false_expression - self.split_ternary_node(node, condition, true_expr, false_expr) + self._split_ternary_node(node, condition, true_expr, false_expr) ternary_found = True + updated = True break + return updated - def split_ternary_node(self, node, condition, true_expr, false_expr): + def _split_ternary_node(self, node, condition, true_expr, false_expr): condition_node = self._new_node(NodeType.IF, node.source_mapping) condition_node.add_expression(condition) condition_node.analyze_expressions(self) diff --git a/slither/visitors/slithir/expression_to_slithir.py b/slither/visitors/slithir/expression_to_slithir.py index 753bd82eb..f4ffd91a1 100644 --- a/slither/visitors/slithir/expression_to_slithir.py +++ b/slither/visitors/slithir/expression_to_slithir.py @@ -256,5 +256,5 @@ class ExpressionToSlithIR(ExpressionVisitor): self._result.append(operation) set_val(expression, lvalue) else: - raise Exception('Unary operation to IR not supported {}'.format(expression)) + raise SlithIRError('Unary operation to IR not supported {}'.format(expression)) diff --git a/tests/expected_json/void-cst.void-cst.json b/tests/expected_json/void-cst.void-cst.json new file mode 100644 index 000000000..ab97b9d7d --- /dev/null +++ b/tests/expected_json/void-cst.void-cst.json @@ -0,0 +1,130 @@ +{ + "success": true, + "error": null, + "results": { + "detectors": [ + { + "check": "void-cst", + "impact": "Low", + "confidence": "High", + "description": "Void constructor called in D.constructor() (tests/void-cst.sol#10-12):\n\t-C() tests/void-cst.sol#10\n", + "elements": [ + { + "type": "function", + "name": "constructor", + "source_mapping": { + "start": 41, + "length": 32, + "filename_used": "/home/travis/build/crytic/slither/tests/void-cst.sol", + "filename_relative": "tests/void-cst.sol", + "filename_absolute": "/home/travis/build/crytic/slither/tests/void-cst.sol", + "filename_short": "tests/void-cst.sol", + "is_dependency": false, + "lines": [ + 10, + 11, + 12 + ], + "starting_column": 5, + "ending_column": 6 + }, + "type_specific_fields": { + "parent": { + "type": "contract", + "name": "D", + "source_mapping": { + "start": 19, + "length": 57, + "filename_used": "/home/travis/build/crytic/slither/tests/void-cst.sol", + "filename_relative": "tests/void-cst.sol", + "filename_absolute": "/home/travis/build/crytic/slither/tests/void-cst.sol", + "filename_short": "tests/void-cst.sol", + "is_dependency": false, + "lines": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14 + ], + "starting_column": 1, + "ending_column": 2 + } + }, + "signature": "constructor()" + } + }, + { + "type": "node", + "name": "C()", + "source_mapping": { + "start": 62, + "length": 3, + "filename_used": "/home/travis/build/crytic/slither/tests/void-cst.sol", + "filename_relative": "tests/void-cst.sol", + "filename_absolute": "/home/travis/build/crytic/slither/tests/void-cst.sol", + "filename_short": "tests/void-cst.sol", + "is_dependency": false, + "lines": [ + 10 + ], + "starting_column": 26, + "ending_column": 29 + }, + "type_specific_fields": { + "parent": { + "type": "function", + "name": "constructor", + "source_mapping": { + "start": 41, + "length": 32, + "filename_used": "/home/travis/build/crytic/slither/tests/void-cst.sol", + "filename_relative": "tests/void-cst.sol", + "filename_absolute": "/home/travis/build/crytic/slither/tests/void-cst.sol", + "filename_short": "tests/void-cst.sol", + "is_dependency": false, + "lines": [ + 10, + 11, + 12 + ], + "starting_column": 5, + "ending_column": 6 + }, + "type_specific_fields": { + "parent": { + "type": "contract", + "name": "D", + "source_mapping": { + "start": 19, + "length": 57, + "filename_used": "/home/travis/build/crytic/slither/tests/void-cst.sol", + "filename_relative": "tests/void-cst.sol", + "filename_absolute": "/home/travis/build/crytic/slither/tests/void-cst.sol", + "filename_short": "tests/void-cst.sol", + "is_dependency": false, + "lines": [ + 8, + 9, + 10, + 11, + 12, + 13, + 14 + ], + "starting_column": 1, + "ending_column": 2 + } + }, + "signature": "constructor()" + } + } + } + } + ] + } + ] + } +} \ No newline at end of file diff --git a/tests/expected_json/void-cst.void-cst.txt b/tests/expected_json/void-cst.void-cst.txt new file mode 100644 index 000000000..cc3473967 --- /dev/null +++ b/tests/expected_json/void-cst.void-cst.txt @@ -0,0 +1,5 @@ +INFO:Detectors: +Void constructor called in D.constructor() (tests/void-cst.sol#10-12): + -C() tests/void-cst.sol#10 +Reference: https://github.com/crytic/slither/wiki/Detector-Documentation#void-constructor +INFO:Slither:tests/void-cst.sol analyzed (2 contracts), 1 result(s) found diff --git a/tests/void-cst.sol b/tests/void-cst.sol new file mode 100644 index 000000000..43edc9d9a --- /dev/null +++ b/tests/void-cst.sol @@ -0,0 +1,14 @@ + + +contract C{ + + +} + +contract D is C{ + + constructor() public C(){ + + } + +} From ab96c09d0885cd62e0161882b39aea689586509f Mon Sep 17 00:00:00 2001 From: Josselin Date: Wed, 24 Jul 2019 08:57:16 +0200 Subject: [PATCH 110/223] Minor --- scripts/travis_test_5.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scripts/travis_test_5.sh b/scripts/travis_test_5.sh index bb598ac1f..4b3928b5c 100755 --- a/scripts/travis_test_5.sh +++ b/scripts/travis_test_5.sh @@ -69,7 +69,7 @@ test_slither(){ } -test_slither tests/void-cst.json "void-cst" +test_slither tests/void-cst.sol "void-cst" test_slither tests/solc_version_incorrect_05.ast.json "solc-version" test_slither tests/unchecked_lowlevel-0.5.1.sol "unchecked-lowlevel" test_slither tests/unchecked_send-0.5.1.sol "unchecked-send" From 8bac6f5d87c99707a065da48b38a92a5e6c3a0a3 Mon Sep 17 00:00:00 2001 From: Josselin Date: Wed, 24 Jul 2019 10:32:33 +0200 Subject: [PATCH 111/223] Use the master branch from crytic-compile --- setup.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/setup.py b/setup.py index d6642a502..48e51c1a8 100644 --- a/setup.py +++ b/setup.py @@ -8,7 +8,9 @@ setup( version='0.6.4', packages=find_packages(), python_requires='>=3.6', - install_requires=['prettytable>=0.7.2', 'pysha3>=1.0.2', 'crytic-compile>=0.1.1'], + install_requires=['prettytable>=0.7.2', + 'pysha3>=1.0.2', + 'git+https://github.com/crytic/crytic-compile.git'], license='AGPL-3.0', long_description=open('README.md').read(), entry_points={ From e5175e79a4bbcd4e26cf25c4f8ddfa3ab8950b1a Mon Sep 17 00:00:00 2001 From: Josselin Date: Wed, 24 Jul 2019 10:46:44 +0200 Subject: [PATCH 112/223] Use dependency_links in setup.py --- setup.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/setup.py b/setup.py index 48e51c1a8..cd1248087 100644 --- a/setup.py +++ b/setup.py @@ -10,7 +10,8 @@ setup( python_requires='>=3.6', install_requires=['prettytable>=0.7.2', 'pysha3>=1.0.2', - 'git+https://github.com/crytic/crytic-compile.git'], + 'crytic-compile'], + dependency_links=['git+https://github.com/crytic/crytic-compile.git@master#egg=crytic-compile'], license='AGPL-3.0', long_description=open('README.md').read(), entry_points={ From 17e8f1b7b06ac97b54b47c6d1895cb50cf3cc4d8 Mon Sep 17 00:00:00 2001 From: Josselin Date: Wed, 24 Jul 2019 10:48:23 +0200 Subject: [PATCH 113/223] Remove custom crytic-compile install in travis_install.sh --- scripts/travis_install.sh | 7 ------- 1 file changed, 7 deletions(-) diff --git a/scripts/travis_install.sh b/scripts/travis_install.sh index e043c9c16..2f55834a3 100755 --- a/scripts/travis_install.sh +++ b/scripts/travis_install.sh @@ -1,12 +1,5 @@ #!/usr/bin/env bash -# TODO: temporary until the next crytic-compile release -git clone https://github.com/crytic/crytic-compile -cd crytic-compile -git checkout dev -python setup.py install -cd .. - python setup.py install # Used by travis_test.sh pip install deepdiff From e30709932c1e440ce5eb5fbbf58d78e858d4b8a2 Mon Sep 17 00:00:00 2001 From: Feist Josselin Date: Wed, 24 Jul 2019 10:52:05 +0200 Subject: [PATCH 114/223] Update README.md --- README.md | 5 ----- 1 file changed, 5 deletions(-) diff --git a/README.md b/README.md index 55e55d9c4..0a2f48f3e 100644 --- a/README.md +++ b/README.md @@ -112,12 +112,7 @@ $ pip install slither-analyzer ### Using Git -Installing through git requires installing [crytic-compile](https://github.com/crytic/crytic-compile) from git too: - ```bash -$ git clone https://github.com/crytic/crytic-compile.git && cd crytic-compile -$ python setup.py install -$ cd .. $ git clone https://github.com/crytic/slither.git && cd slither $ python setup.py install ``` From 3805fdf6df7726d77029076f77ecda676b58c95c Mon Sep 17 00:00:00 2001 From: Josselin Date: Sat, 27 Jul 2019 21:32:47 +0200 Subject: [PATCH 115/223] Improve abi.decode parsing support --- slither/solc_parsing/expressions/expression_parsing.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/slither/solc_parsing/expressions/expression_parsing.py b/slither/solc_parsing/expressions/expression_parsing.py index 5055c886f..d6e41f0d9 100644 --- a/slither/solc_parsing/expressions/expression_parsing.py +++ b/slither/solc_parsing/expressions/expression_parsing.py @@ -579,7 +579,7 @@ def parse_expression(expression, caller_context): # if abi.decode is used # For example, abi.decode(data, ...(uint[]) ) if right is None: - return _parse_elementary_type_name_expression(left, is_compact_ast, caller_context) + return parse_expression(left, caller_context) left_expression = parse_expression(left, caller_context) right_expression = parse_expression(right, caller_context) From ab309ec81e51d44ba7600bcec26578d85e0f22fe Mon Sep 17 00:00:00 2001 From: Josselin Date: Sat, 27 Jul 2019 21:51:12 +0200 Subject: [PATCH 116/223] Parsing/IR: late conversion of the subdenomination value to improve too many digit detector (fix #297) --- slither/core/expressions/literal.py | 10 +++- .../detectors/statements/too_many_digits.py | 1 - slither/slithir/variables/constant.py | 8 ++- .../expressions/expression_parsing.py | 49 +++---------------- slither/utils/arithmetic.py | 32 ++++++++++++ .../visitors/slithir/expression_to_slithir.py | 2 +- tests/too_many_digits.sol | 5 ++ 7 files changed, 61 insertions(+), 46 deletions(-) create mode 100644 slither/utils/arithmetic.py diff --git a/slither/core/expressions/literal.py b/slither/core/expressions/literal.py index c1923eff4..1e9b96ec3 100644 --- a/slither/core/expressions/literal.py +++ b/slither/core/expressions/literal.py @@ -1,11 +1,13 @@ from slither.core.expressions.expression import Expression +from slither.utils.arithmetic import convert_subdenomination class Literal(Expression): - def __init__(self, value, type): + def __init__(self, value, type, subdenomination=None): super(Literal, self).__init__() self._value = value self._type = type + self._subdenomination = subdenomination @property def value(self): @@ -15,6 +17,12 @@ class Literal(Expression): def type(self): return self._type + @property + def subdenomination(self): + return self._subdenomination + def __str__(self): + if self.subdenomination: + return str(convert_subdenomination(self._value, self.subdenomination)) # be sure to handle any character return str(self._value) diff --git a/slither/detectors/statements/too_many_digits.py b/slither/detectors/statements/too_many_digits.py index b5565094d..6b74fb9f4 100644 --- a/slither/detectors/statements/too_many_digits.py +++ b/slither/detectors/statements/too_many_digits.py @@ -48,7 +48,6 @@ Use: if isinstance(read, Constant): # read.value can return an int or a str. Convert it to str value_as_str = read.original_value - line_of_code = str(node.expression) if '00000' in value_as_str: # Info to be printed ret.append(node) diff --git a/slither/slithir/variables/constant.py b/slither/slithir/variables/constant.py index 64c3e4fdf..10802ac09 100644 --- a/slither/slithir/variables/constant.py +++ b/slither/slithir/variables/constant.py @@ -1,14 +1,18 @@ from .variable import SlithIRVariable from slither.core.solidity_types.elementary_type import ElementaryType, Int, Uint - +from slither.utils.arithmetic import convert_subdenomination class Constant(SlithIRVariable): - def __init__(self, val, type=None): + def __init__(self, val, type=None, subdenomination=None): super(Constant, self).__init__() assert isinstance(val, str) self._original_value = val + self._subdenomination = subdenomination + + if subdenomination: + val = str(convert_subdenomination(val, subdenomination)) if type: assert isinstance(type, ElementaryType) diff --git a/slither/solc_parsing/expressions/expression_parsing.py b/slither/solc_parsing/expressions/expression_parsing.py index d6e41f0d9..12837733c 100644 --- a/slither/solc_parsing/expressions/expression_parsing.py +++ b/slither/solc_parsing/expressions/expression_parsing.py @@ -220,45 +220,7 @@ def filter_name(value): return value # endregion -################################################################################### -################################################################################### -# region Conversion -################################################################################### -################################################################################### - -def convert_subdenomination(value, sub): - if sub is None: - return value - # to allow 0.1 ether conversion - if value[0:2] == "0x": - value = float(int(value, 16)) - else: - value = float(value) - if sub == 'wei': - return int(value) - if sub == 'szabo': - return int(value * int(1e12)) - if sub == 'finney': - return int(value * int(1e15)) - if sub == 'ether': - return int(value * int(1e18)) - if sub == 'seconds': - return int(value) - if sub == 'minutes': - return int(value * 60) - if sub == 'hours': - return int(value * 60 * 60) - if sub == 'days': - return int(value * 60 * 60 * 24) - if sub == 'weeks': - return int(value * 60 * 60 * 24 * 7) - if sub == 'years': - return int(value * 60 * 60 * 24 * 7 * 365) - - logger.error('Subdemoniation not found {}'.format(sub)) - return int(value) -# endregion ################################################################################### ################################################################################### # region Parsing @@ -489,14 +451,19 @@ def parse_expression(expression, caller_context): assignement = AssignmentOperation(left_expression, right_expression, operation_type, operation_return_type) return assignement + + elif name == 'Literal': + + subdenomination = None + assert 'children' not in expression if is_compact_ast: value = expression['value'] if value: if 'subdenomination' in expression and expression['subdenomination']: - value = str(convert_subdenomination(value, expression['subdenomination'])) + subdenomination = expression['subdenomination'] elif not value and value != "": value = '0x'+expression['hexValue'] type = expression['typeDescriptions']['typeString'] @@ -509,7 +476,7 @@ def parse_expression(expression, caller_context): value = expression['attributes']['value'] if value: if 'subdenomination' in expression['attributes'] and expression['attributes']['subdenomination']: - value = str(convert_subdenomination(value, expression['attributes']['subdenomination'])) + subdenomination = expression['subdenomination'] elif value is None: # for literal declared as hex # see https://solidity.readthedocs.io/en/v0.4.25/types.html?highlight=hex#hexadecimal-literals @@ -530,7 +497,7 @@ def parse_expression(expression, caller_context): type = ElementaryType('address') else: type = ElementaryType('string') - literal = Literal(value, type) + literal = Literal(value, type, subdenomination) return literal elif name == 'Identifier': diff --git a/slither/utils/arithmetic.py b/slither/utils/arithmetic.py new file mode 100644 index 000000000..241eca28a --- /dev/null +++ b/slither/utils/arithmetic.py @@ -0,0 +1,32 @@ +from slither.exceptions import SlitherException + + +def convert_subdenomination(value, sub): + + # to allow 0.1 ether conversion + if value[0:2] == "0x": + value = float(int(value, 16)) + else: + value = float(value) + if sub == 'wei': + return int(value) + if sub == 'szabo': + return int(value * int(1e12)) + if sub == 'finney': + return int(value * int(1e15)) + if sub == 'ether': + return int(value * int(1e18)) + if sub == 'seconds': + return int(value) + if sub == 'minutes': + return int(value * 60) + if sub == 'hours': + return int(value * 60 * 60) + if sub == 'days': + return int(value * 60 * 60 * 24) + if sub == 'weeks': + return int(value * 60 * 60 * 24 * 7) + if sub == 'years': + return int(value * 60 * 60 * 24 * 7 * 365) + + raise SlitherException(f'Subdemonination conversion impossible {value} {sub}') \ No newline at end of file diff --git a/slither/visitors/slithir/expression_to_slithir.py b/slither/visitors/slithir/expression_to_slithir.py index f4ffd91a1..2ad5670fd 100644 --- a/slither/visitors/slithir/expression_to_slithir.py +++ b/slither/visitors/slithir/expression_to_slithir.py @@ -171,7 +171,7 @@ class ExpressionToSlithIR(ExpressionVisitor): set_val(expression, val) def _post_literal(self, expression): - cst = Constant(expression.value, expression.type) + cst = Constant(expression.value, expression.type, expression.subdenomination) set_val(expression, cst) def _post_member_access(self, expression): diff --git a/tests/too_many_digits.sol b/tests/too_many_digits.sol index 84e930056..6156d0da5 100644 --- a/tests/too_many_digits.sol +++ b/tests/too_many_digits.sol @@ -31,5 +31,10 @@ contract C { uint x2 = 1 szabo + 10 szabo + 100 szabo + 1000 szabo + 10000 szabo; balance += x1 + x2; } + + function good() external{ + + uint x = 1 ether; + } } From cc3377bd338e09586f9ddd830132620be4d46ff9 Mon Sep 17 00:00:00 2001 From: Josselin Date: Sat, 27 Jul 2019 22:31:29 +0200 Subject: [PATCH 117/223] Minor --- slither/core/declarations/function.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/slither/core/declarations/function.py b/slither/core/declarations/function.py index c0f5b2687..b9e981375 100644 --- a/slither/core/declarations/function.py +++ b/slither/core/declarations/function.py @@ -143,7 +143,7 @@ class Function(ChildContract, ChildInheritance, SourceMapping): """ str: function name """ - if self._function_type == FunctionType.CONSTRUCTOR: + if self._name == '' and self._function_type == FunctionType.CONSTRUCTOR: return 'constructor' elif self._function_type == FunctionType.FALLBACK: return 'fallback' From 24eb049ffb1ec82f4410ead2195315ab759fa474 Mon Sep 17 00:00:00 2001 From: Josselin Date: Sun, 28 Jul 2019 09:46:30 +0200 Subject: [PATCH 118/223] Improve raw json support --- slither/core/slither_core.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/slither/core/slither_core.py b/slither/core/slither_core.py index f10831ffe..2747416fd 100644 --- a/slither/core/slither_core.py +++ b/slither/core/slither_core.py @@ -61,7 +61,7 @@ class Slither(Context): :param path: :return: """ - if path in self.crytic_compile.src_content: + if self.crytic_compile and path in self.crytic_compile.src_content: self.source_code[path] = self.crytic_compile.src_content[path] else: with open(path, encoding='utf8', newline='') as f: From 36d56d0b939ba07210190d26e3dada31a5661372 Mon Sep 17 00:00:00 2001 From: Josselin Date: Sun, 28 Jul 2019 10:47:23 +0200 Subject: [PATCH 119/223] Update README.md --- README.md | 30 ++++++++++++++++-------------- 1 file changed, 16 insertions(+), 14 deletions(-) diff --git a/README.md b/README.md index 0a2f48f3e..ec9e762b0 100644 --- a/README.md +++ b/README.md @@ -61,20 +61,22 @@ Num | Detector | What it Detects | Impact | Confidence 20 | `unused-return` | [Unused return values](https://github.com/crytic/slither/wiki/Detector-Documentation#unused-return) | Medium | Medium 21 | `shadowing-builtin` | [Built-in symbol shadowing](https://github.com/crytic/slither/wiki/Detector-Documentation#builtin-symbol-shadowing) | Low | High 22 | `shadowing-local` | [Local variables shadowing](https://github.com/crytic/slither/wiki/Detector-Documentation#local-variable-shadowing) | Low | High -23 | `calls-loop` | [Multiple calls in a loop](https://github.com/crytic/slither/wiki/Detector-Documentation/_edit#calls-inside-a-loop) | Low | Medium -24 | `reentrancy-benign` | [Benign reentrancy vulnerabilities](https://github.com/crytic/slither/wiki/Detector-Documentation#reentrancy-vulnerabilities-2) | Low | Medium -25 | `timestamp` | [Dangerous usage of `block.timestamp`](https://github.com/crytic/slither/wiki/Detector-Documentation#block-timestamp) | Low | Medium -26 | `assembly` | [Assembly usage](https://github.com/crytic/slither/wiki/Detector-Documentation#assembly-usage) | Informational | High -27 | `deprecated-standards` | [Deprecated Solidity Standards](https://github.com/crytic/slither/wiki/Detector-Documentation#deprecated-standards) | Informational | High -28 | `erc20-indexed` | [Un-indexed ERC20 event parameters](https://github.com/crytic/slither/wiki/Detector-Documentation#unindexed-erc20-event-parameters) | Informational | High -29 | `low-level-calls` | [Low level calls](https://github.com/crytic/slither/wiki/Detector-Documentation#low-level-calls) | Informational | High -30 | `naming-convention` | [Conformance to Solidity naming conventions](https://github.com/crytic/slither/wiki/Detector-Documentation#conformance-to-solidity-naming-conventions) | Informational | High -31 | `pragma` | [If different pragma directives are used](https://github.com/crytic/slither/wiki/Detector-Documentation#different-pragma-directives-are-used) | Informational | High -32 | `solc-version` | [Incorrect Solidity version (< 0.4.24 or complex pragma)](https://github.com/crytic/slither/wiki/Detector-Documentation#incorrect-versions-of-solidity) | Informational | High -33 | `unused-state` | [Unused state variables](https://github.com/crytic/slither/wiki/Detector-Documentation#unused-state-variables) | Informational | High -34 | `too-many-digits` | [Conformance to numeric notation best practices](https://github.com/crytic/slither/wiki/Detector-Documentation#too-many-digits) | Informational | Medium -35 | `constable-states` | [State variables that could be declared constant](https://github.com/crytic/slither/wiki/Detector-Documentation#state-variables-that-could-be-declared-constant) | Optimization | High -36 | `external-function` | [Public function that could be declared as external](https://github.com/crytic/slither/wiki/Detector-Documentation#public-function-that-could-be-declared-as-external) | Optimization | High +23 | `void-cst` | [Constructor called not implemented](https://github.com/crytic/slither/wiki/Detector-Documentation#void-constructor) | Low | High +24 | `calls-loop` | [Multiple calls in a loop](https://github.com/crytic/slither/wiki/Detector-Documentation/_edit#calls-inside-a-loop) | Low | Medium +25 | `reentrancy-benign` | [Benign reentrancy vulnerabilities](https://github.com/crytic/slither/wiki/Detector-Documentation#reentrancy-vulnerabilities-2) | Low | Medium +26 | `timestamp` | [Dangerous usage of `block.timestamp`](https://github.com/crytic/slither/wiki/Detector-Documentation#block-timestamp) | Low | Medium +27 | `assembly` | [Assembly usage](https://github.com/crytic/slither/wiki/Detector-Documentation#assembly-usage) | Informational | High +28 | `deprecated-standards` | [Deprecated Solidity Standards](https://github.com/crytic/slither/wiki/Detector-Documentation#deprecated-standards) | Informational | High +29 | `erc20-indexed` | [Un-indexed ERC20 event parameters](https://github.com/crytic/slither/wiki/Detector-Documentation#unindexed-erc20-event-parameters) | Informational | High +30 | `low-level-calls` | [Low level calls](https://github.com/crytic/slither/wiki/Detector-Documentation#low-level-calls) | Informational | High +31 | `naming-convention` | [Conformance to Solidity naming conventions](https://github.com/crytic/slither/wiki/Detector-Documentation#conformance-to-solidity-naming-conventions) | Informational | High +32 | `pragma` | [If different pragma directives are used](https://github.com/crytic/slither/wiki/Detector-Documentation#different-pragma-directives-are-used) | Informational | High +33 | `solc-version` | [Incorrect Solidity version (< 0.4.24 or complex pragma)](https://github.com/crytic/slither/wiki/Detector-Documentation#incorrect-versions-of-solidity) | Informational | High +34 | `unused-state` | [Unused state variables](https://github.com/crytic/slither/wiki/Detector-Documentation#unused-state-variables) | Informational | High +35 | `too-many-digits` | [Conformance to numeric notation best practices](https://github.com/crytic/slither/wiki/Detector-Documentation#too-many-digits) | Informational | Medium +36 | `constable-states` | [State variables that could be declared constant](https://github.com/crytic/slither/wiki/Detector-Documentation#state-variables-that-could-be-declared-constant) | Optimization | High +37 | `external-function` | [Public function that could be declared as external](https://github.com/crytic/slither/wiki/Detector-Documentation#public-function-that-could-be-declared-as-external) | Optimization | High + [Contact us](https://www.trailofbits.com/contact/) to get access to additional detectors. From 1ac85718729809b205a6c3b7f78d8f2b9a66cd1c Mon Sep 17 00:00:00 2001 From: Josselin Date: Sun, 28 Jul 2019 10:50:04 +0200 Subject: [PATCH 120/223] Markdown typo in void constructor --- slither/detectors/operations/void_constructor.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/slither/detectors/operations/void_constructor.py b/slither/detectors/operations/void_constructor.py index 6f2097e75..756f88538 100644 --- a/slither/detectors/operations/void_constructor.py +++ b/slither/detectors/operations/void_constructor.py @@ -15,7 +15,7 @@ class VoidConstructor(AbstractDetector): WIKI_DESCRIPTION = 'Detect the call to a constructor not implemented' WIKI_RECOMMENDATION = 'Remove the constructor call.' WIKI_EXPLOIT_SCENARIO = ''' - ```solidity +```solidity contract A{} contract B is A{ constructor() public A(){} From a9dea21ca83ad31abd93d31388a02899c079b3e4 Mon Sep 17 00:00:00 2001 From: Josselin Date: Sun, 28 Jul 2019 10:57:40 +0200 Subject: [PATCH 121/223] Update travis tests --- scripts/tests_generate_expected_json_5.sh | 2 +- .../too_many_digits.too-many-digits.json | 148 +++++------------- .../too_many_digits.too-many-digits.txt | 6 +- 3 files changed, 38 insertions(+), 118 deletions(-) diff --git a/scripts/tests_generate_expected_json_5.sh b/scripts/tests_generate_expected_json_5.sh index 78cc2b3ef..620fc0b0c 100755 --- a/scripts/tests_generate_expected_json_5.sh +++ b/scripts/tests_generate_expected_json_5.sh @@ -20,7 +20,7 @@ generate_expected_json(){ sed "s|$CURRENT_PATH|$TRAVIS_PATH|g" "$output_filename_txt" -i } -generate_expected_json tests/void-cst.sol "void-cst" +#generate_expected_json tests/void-cst.sol "void-cst" #generate_expected_json tests/solc_version_incorrect_05.ast.json "solc-version" #generate_expected_json tests/uninitialized-0.5.1.sol "uninitialized-state" #generate_expected_json tests/backdoor.sol "backdoor" diff --git a/tests/expected_json/too_many_digits.too-many-digits.json b/tests/expected_json/too_many_digits.too-many-digits.json index a8f2311f6..0e8cf635f 100644 --- a/tests/expected_json/too_many_digits.too-many-digits.json +++ b/tests/expected_json/too_many_digits.too-many-digits.json @@ -56,7 +56,7 @@ "name": "C", "source_mapping": { "start": 25, - "length": 833, + "length": 897, "filename_used": "/home/travis/build/crytic/slither/tests/too_many_digits.sol", "filename_relative": "tests/too_many_digits.sol", "filename_absolute": "/home/travis/build/crytic/slither/tests/too_many_digits.sol", @@ -95,7 +95,12 @@ 32, 33, 34, - 35 + 35, + 36, + 37, + 38, + 39, + 40 ], "starting_column": 1, "ending_column": 2 @@ -161,7 +166,7 @@ "name": "C", "source_mapping": { "start": 25, - "length": 833, + "length": 897, "filename_used": "/home/travis/build/crytic/slither/tests/too_many_digits.sol", "filename_relative": "tests/too_many_digits.sol", "filename_absolute": "/home/travis/build/crytic/slither/tests/too_many_digits.sol", @@ -200,7 +205,12 @@ 32, 33, 34, - 35 + 35, + 36, + 37, + 38, + 39, + 40 ], "starting_column": 1, "ending_column": 2 @@ -266,7 +276,7 @@ "name": "C", "source_mapping": { "start": 25, - "length": 833, + "length": 897, "filename_used": "/home/travis/build/crytic/slither/tests/too_many_digits.sol", "filename_relative": "tests/too_many_digits.sol", "filename_absolute": "/home/travis/build/crytic/slither/tests/too_many_digits.sol", @@ -305,7 +315,12 @@ 32, 33, 34, - 35 + 35, + 36, + 37, + 38, + 39, + 40 ], "starting_column": 1, "ending_column": 2 @@ -371,7 +386,7 @@ "name": "C", "source_mapping": { "start": 25, - "length": 833, + "length": 897, "filename_used": "/home/travis/build/crytic/slither/tests/too_many_digits.sol", "filename_relative": "tests/too_many_digits.sol", "filename_absolute": "/home/travis/build/crytic/slither/tests/too_many_digits.sol", @@ -410,7 +425,12 @@ 32, 33, 34, - 35 + 35, + 36, + 37, + 38, + 39, + 40 ], "starting_column": 1, "ending_column": 2 @@ -474,7 +494,7 @@ "name": "C", "source_mapping": { "start": 25, - "length": 833, + "length": 897, "filename_used": "/home/travis/build/crytic/slither/tests/too_many_digits.sol", "filename_relative": "tests/too_many_digits.sol", "filename_absolute": "/home/travis/build/crytic/slither/tests/too_many_digits.sol", @@ -513,7 +533,12 @@ 32, 33, 34, - 35 + 35, + 36, + 37, + 38, + 39, + 40 ], "starting_column": 1, "ending_column": 2 @@ -525,109 +550,6 @@ } } ] - }, - { - "check": "too-many-digits", - "impact": "Informational", - "confidence": "Medium", - "description": "C.i (tests/too_many_digits.sol#29-33) uses literals with too many digits:\n\t- x2 = 1000000000000 + 10000000000000 + 100000000000000 + 1000000000000000 + 10000000000000000\n", - "elements": [ - { - "type": "node", - "name": "x2 = 1000000000000 + 10000000000000 + 100000000000000 + 1000000000000000 + 10000000000000000", - "source_mapping": { - "start": 749, - "length": 67, - "filename_used": "/home/travis/build/crytic/slither/tests/too_many_digits.sol", - "filename_relative": "tests/too_many_digits.sol", - "filename_absolute": "/home/travis/build/crytic/slither/tests/too_many_digits.sol", - "filename_short": "tests/too_many_digits.sol", - "is_dependency": false, - "lines": [ - 31 - ], - "starting_column": 9, - "ending_column": 76 - }, - "type_specific_fields": { - "parent": { - "type": "function", - "name": "i", - "source_mapping": { - "start": 650, - "length": 201, - "filename_used": "/home/travis/build/crytic/slither/tests/too_many_digits.sol", - "filename_relative": "tests/too_many_digits.sol", - "filename_absolute": "/home/travis/build/crytic/slither/tests/too_many_digits.sol", - "filename_short": "tests/too_many_digits.sol", - "is_dependency": false, - "lines": [ - 29, - 30, - 31, - 32, - 33 - ], - "starting_column": 5, - "ending_column": 6 - }, - "type_specific_fields": { - "parent": { - "type": "contract", - "name": "C", - "source_mapping": { - "start": 25, - "length": 833, - "filename_used": "/home/travis/build/crytic/slither/tests/too_many_digits.sol", - "filename_relative": "tests/too_many_digits.sol", - "filename_absolute": "/home/travis/build/crytic/slither/tests/too_many_digits.sol", - "filename_short": "tests/too_many_digits.sol", - "is_dependency": false, - "lines": [ - 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 - ], - "starting_column": 1, - "ending_column": 2 - } - }, - "signature": "i()" - } - } - } - } - ] } ] } diff --git a/tests/expected_json/too_many_digits.too-many-digits.txt b/tests/expected_json/too_many_digits.too-many-digits.txt index ccc93c52d..4e5ecbaa1 100644 --- a/tests/expected_json/too_many_digits.too-many-digits.txt +++ b/tests/expected_json/too_many_digits.too-many-digits.txt @@ -1,4 +1,4 @@ -INFO:Detectors: + C.f (tests/too_many_digits.sol#9-15) uses literals with too many digits: - x1 = 0x000001 C.f (tests/too_many_digits.sol#9-15) uses literals with too many digits: @@ -9,7 +9,5 @@ C.f (tests/too_many_digits.sol#9-15) uses literals with too many digits: - x4 = 100000 C.h (tests/too_many_digits.sol#20-24) uses literals with too many digits: - x2 = 100000 -C.i (tests/too_many_digits.sol#29-33) uses literals with too many digits: - - x2 = 1000000000000 + 10000000000000 + 100000000000000 + 1000000000000000 + 10000000000000000 Reference: https://github.com/crytic/slither/wiki/Detector-Documentation#too-many-digits -INFO:Slither:tests/too_many_digits.sol analyzed (1 contracts), 6 result(s) found +tests/too_many_digits.sol analyzed (1 contracts), 5 result(s) found From aec680c5feee219094357bef251cd07d7212411c Mon Sep 17 00:00:00 2001 From: Josselin Date: Sun, 28 Jul 2019 11:04:33 +0200 Subject: [PATCH 122/223] Naming convetion: do not report incorrect naming convention for constructor --- slither/detectors/naming_convention/naming_convention.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/slither/detectors/naming_convention/naming_convention.py b/slither/detectors/naming_convention/naming_convention.py index 6c72f4438..f1f35507c 100644 --- a/slither/detectors/naming_convention/naming_convention.py +++ b/slither/detectors/naming_convention/naming_convention.py @@ -92,6 +92,8 @@ Solidity defines a [naming convention](https://solidity.readthedocs.io/en/v0.4.2 results.append(json) for func in contract.functions_declared: + if func.is_constructor: + continue if not self.is_mixed_case(func.name): if func.visibility in ['internal', 'private'] and self.is_mixed_case_with_underscore(func.name): continue From 2ff1b296a103c8fa082836710f4f3f7623a67a00 Mon Sep 17 00:00:00 2001 From: Josselin Date: Tue, 30 Jul 2019 11:16:54 +0200 Subject: [PATCH 123/223] Minor --- slither/solc_parsing/slitherSolc.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/slither/solc_parsing/slitherSolc.py b/slither/solc_parsing/slitherSolc.py index e6ac1c932..70e276f19 100644 --- a/slither/solc_parsing/slitherSolc.py +++ b/slither/solc_parsing/slitherSolc.py @@ -224,11 +224,11 @@ class SlitherSolc(Slither): else: father_constructors.append(self._contracts_by_id[i]) - except KeyError: - txt = 'A contract was not found, it is likely that your codebase contains muliple contracts with the same name' - txt += 'Truffle does not handle this case during compilation' - txt += 'Please read https://github.com/trailofbits/slither/wiki#keyerror-or-nonetype-error' - txt += 'And update your code to remove the duplicate' + except KeyError as e: + txt = f'A contract was not found (id {e}), it is likely that your codebase contains muliple contracts with the same name. ' + txt += 'Truffle does not handle this case during compilation. ' + txt += 'Please read https://github.com/trailofbits/slither/wiki#keyerror-or-nonetype-error, ' + txt += 'and update your code to remove the duplicate' raise ParsingContractNotFound(txt) contract.setInheritance(ancestors, fathers, father_constructors) From 13528d26d94ef56c0c05f54540cc04accba14a8d Mon Sep 17 00:00:00 2001 From: Josselin Date: Tue, 30 Jul 2019 17:48:49 +0200 Subject: [PATCH 124/223] Minor --- slither/solc_parsing/expressions/expression_parsing.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/slither/solc_parsing/expressions/expression_parsing.py b/slither/solc_parsing/expressions/expression_parsing.py index 12837733c..e76deb8fd 100644 --- a/slither/solc_parsing/expressions/expression_parsing.py +++ b/slither/solc_parsing/expressions/expression_parsing.py @@ -476,7 +476,7 @@ def parse_expression(expression, caller_context): value = expression['attributes']['value'] if value: if 'subdenomination' in expression['attributes'] and expression['attributes']['subdenomination']: - subdenomination = expression['subdenomination'] + subdenomination = expression['attributes']['subdenomination'] elif value is None: # for literal declared as hex # see https://solidity.readthedocs.io/en/v0.4.25/types.html?highlight=hex#hexadecimal-literals From 58abfbb477ad976294fe5df580966b93030794ce Mon Sep 17 00:00:00 2001 From: Josselin Date: Tue, 6 Aug 2019 10:27:01 +0200 Subject: [PATCH 125/223] Refactor reentrancy + API changes: - Move can reenter / can send eth logics to the IR level - Add create-based reentrancy (https://github.com/crytic/slither/issues/310) --- slither/core/cfg/node.py | 37 ++++++++++++++ slither/core/children/child_node.py | 4 ++ slither/core/declarations/function.py | 41 +++++++++++++-- slither/detectors/reentrancy/reentrancy.py | 39 +++------------ slither/slithir/operations/call.py | 13 +++++ slither/slithir/operations/high_level_call.py | 50 +++++++++++++++++++ slither/slithir/operations/library_call.py | 12 +++++ slither/slithir/operations/low_level_call.py | 14 ++++++ slither/slithir/operations/new_contract.py | 40 ++++++++++++++- slither/utils/function.py | 1 - 10 files changed, 214 insertions(+), 37 deletions(-) diff --git a/slither/core/cfg/node.py b/slither/core/cfg/node.py index 4251b0bad..5bcb000b3 100644 --- a/slither/core/cfg/node.py +++ b/slither/core/cfg/node.py @@ -200,6 +200,10 @@ class Node(SourceMapping, ChildFunction): self._expression_vars_read = [] self._expression_calls = [] + # Computed on the fly, can be True of False + self._can_reenter = None + self._can_send_eth = None + ################################################################################### ################################################################################### # region General's properties @@ -402,6 +406,39 @@ class Node(SourceMapping, ChildFunction): def calls_as_expression(self): return list(self._expression_calls) + def can_reenter(self, callstack=None): + ''' + Check if the node can re-enter + Do not consider CREATE as potential re-enter, but check if the + destination's constructor can contain a call (recurs. follow nested CREATE) + For Solidity > 0.5, filter access to public variables and constant/pure/view + For call to this. check if the destination can re-enter + Do not consider Send/Transfer as there is not enough gas + :param callstack: used internally to check for recursion + :return bool: + ''' + from slither.slithir.operations import Call + if self._can_reenter is None: + self._can_reenter = False + for ir in self.irs: + if isinstance(ir, Call) and ir.can_reenter(callstack): + self._can_reenter = True + return True + return self._can_reenter + + def can_send_eth(self): + ''' + Check if the node can send eth + :return bool: + ''' + from slither.slithir.operations import Call + if self._can_send_eth is None: + for ir in self.all_slithir_operations(): + if isinstance(ir, Call) and ir.can_send_eth(): + self._can_send_eth = True + return True + return self._can_reenter + # endregion ################################################################################### ################################################################################### diff --git a/slither/core/children/child_node.py b/slither/core/children/child_node.py index 8c16e3106..bd6fd4e6f 100644 --- a/slither/core/children/child_node.py +++ b/slither/core/children/child_node.py @@ -18,3 +18,7 @@ class ChildNode(object): @property def contract(self): return self.node.function.contract + + @property + def slither(self): + return self.contract.slither \ No newline at end of file diff --git a/slither/core/declarations/function.py b/slither/core/declarations/function.py index b9e981375..71f22ddfc 100644 --- a/slither/core/declarations/function.py +++ b/slither/core/declarations/function.py @@ -132,6 +132,10 @@ class Function(ChildContract, ChildInheritance, SourceMapping): self._function_type = None self._is_constructor = None + # Computed on the fly, can be True of False + self._can_reenter = None + self._can_send_eth = None + ################################################################################### ################################################################################### # region General properties @@ -169,11 +173,44 @@ class Function(ChildContract, ChildInheritance, SourceMapping): name, parameters, _ = self.signature return self.contract_declarer.name + '.' + name + '(' + ','.join(parameters) + ')' - @property def contains_assembly(self): return self._contains_assembly + def can_reenter(self, callstack=None): + ''' + Check if the function can re-enter + Follow internal calls. + Do not consider CREATE as potential re-enter, but check if the + destination's constructor can contain a call (recurs. follow nested CREATE) + For Solidity > 0.5, filter access to public variables and constant/pure/view + For call to this. check if the destination can re-enter + Do not consider Send/Transfer as there is not enough gas + :param callstack: used internally to check for recursion + :return bool: + ''' + from slither.slithir.operations import Call + if self._can_reenter is None: + self._can_reenter = False + for ir in self.all_slithir_operations(): + if isinstance(ir, Call) and ir.can_reenter(callstack): + self._can_reenter = True + return True + return self._can_reenter + + def can_send_eth(self): + ''' + Check if the function can send eth + :return bool: + ''' + from slither.slithir.operations import Call + if self._can_send_eth is None: + for ir in self.all_slithir_operations(): + if isinstance(ir, Call) and ir.can_send_eth(): + self._can_send_eth = True + return True + return self._can_reenter + @property def slither(self): return self.contract.slither @@ -1184,8 +1221,6 @@ class Function(ChildContract, ChildInheritance, SourceMapping): external_calls_as_expressions = [item for sublist in external_calls_as_expressions for item in sublist] self._external_calls_as_expressions = list(set(external_calls_as_expressions)) - - # endregion ################################################################################### ################################################################################### diff --git a/slither/detectors/reentrancy/reentrancy.py b/slither/detectors/reentrancy/reentrancy.py index be5f95dd9..add10ad58 100644 --- a/slither/detectors/reentrancy/reentrancy.py +++ b/slither/detectors/reentrancy/reentrancy.py @@ -11,9 +11,8 @@ from slither.core.expressions import UnaryOperation, UnaryOperationType from slither.detectors.abstract_detector import (AbstractDetector, DetectorClassification) from slither.slithir.operations import (HighLevelCall, LowLevelCall, - LibraryCall, + Call, Send, Transfer) -from slither.core.variables.variable import Variable def union_dict(d1, d2): d3 = {k: d1.get(k, set()) | d2.get(k, set()) for k in set(list(d1.keys()) + list(d2.keys()))} @@ -25,12 +24,6 @@ def dict_are_equal(d1, d2): return all(set(d1[k]) == set(d2[k]) for k in d1.keys()) class Reentrancy(AbstractDetector): -# This detector is not meant to be registered -# It is inherited by reentrancy variantsœ -# ARGUMENT = 'reentrancy' -# HELP = 'Reentrancy vulnerabilities' -# IMPACT = DetectorClassification.HIGH -# CONFIDENCE = DetectorClassification.HIGH KEY = 'REENTRANCY' @@ -43,27 +36,10 @@ class Reentrancy(AbstractDetector): - low level call - high level call - Do not consider Send/Transfer as there is not enough gas + """ for ir in irs: - if isinstance(ir, LowLevelCall): - return True - if isinstance(ir, HighLevelCall) and not isinstance(ir, LibraryCall): - # If solidity >0.5, STATICCALL is used - if self.slither.solc_version and self.slither.solc_version.startswith('0.5.'): - if isinstance(ir.function, Function) and (ir.function.view or ir.function.pure): - continue - if isinstance(ir.function, Variable): - continue - # If there is a call to itself - # We can check that the function called is - # reentrancy-safe - if ir.destination == SolidityVariable('this'): - if isinstance(ir.function, Variable): - continue - if not ir.function.all_high_level_calls(): - if not ir.function.all_low_level_calls(): - continue + if isinstance(ir, Call) and ir.can_reenter(): return True return False @@ -73,9 +49,11 @@ class Reentrancy(AbstractDetector): Detect if the node can send eth """ for ir in irs: - if isinstance(ir, (HighLevelCall, LowLevelCall, Transfer, Send)): - if ir.call_value: - return True + if isinstance(ir, Call) and ir.can_send_eth(): + return True + # if isinstance(ir, (HighLevelCall, LowLevelCall, Transfer, Send)): + # if ir.call_value: + # return True return False def _filter_if(self, node): @@ -174,7 +152,6 @@ class Reentrancy(AbstractDetector): self._explore(son, visited, node) sons = [sons[0]] - for son in sons: self._explore(son, visited) diff --git a/slither/slithir/operations/call.py b/slither/slithir/operations/call.py index 25d929c92..60d150f7f 100644 --- a/slither/slithir/operations/call.py +++ b/slither/slithir/operations/call.py @@ -15,3 +15,16 @@ class Call(Operation): def arguments(self, v): self._arguments = v + def can_reenter(self, callstack=None): + ''' + Must be called after slithIR analysis pass + :return: bool + ''' + return False + + def can_send_eth(self): + ''' + Must be called after slithIR analysis pass + :return: bool + ''' + return False \ No newline at end of file diff --git a/slither/slithir/operations/high_level_call.py b/slither/slithir/operations/high_level_call.py index 87a67a80f..38314c1aa 100644 --- a/slither/slithir/operations/high_level_call.py +++ b/slither/slithir/operations/high_level_call.py @@ -2,6 +2,7 @@ from slither.slithir.operations.call import Call from slither.slithir.operations.lvalue import OperationWithLValue from slither.core.variables.variable import Variable from slither.core.declarations.solidity_variables import SolidityVariable +from slither.core.declarations.function import Function from slither.slithir.utils.utils import is_valid_lvalue from slither.slithir.variables.constant import Constant @@ -86,6 +87,55 @@ class HighLevelCall(Call, OperationWithLValue): def type_call(self): return self._type_call + ################################################################################### + ################################################################################### + # region Analyses + ################################################################################### + ################################################################################### + + def can_reenter(self, callstack=None): + ''' + Must be called after slithIR analysis pass + For Solidity > 0.5, filter access to public variables and constant/pure/view + For call to this. check if the destination can re-enter + :param callstack: check for recursion + :return: bool + ''' + # If solidity >0.5, STATICCALL is used + if self.slither.solc_version and self.slither.solc_version.startswith('0.5.'): + if isinstance(self.function, Function) and (self.function.view or self.function.pure): + return False + if isinstance(self.function, Variable): + return False + # If there is a call to itself + # We can check that the function called is + # reentrancy-safe + if self.destination == SolidityVariable('this'): + if isinstance(self.function, Variable): + return False + # In case of recursion, return False + callstack = [] if callstack is None else callstack + if self.function in callstack: + return False + callstack = callstack + [self.function] + if self.function.can_reenter(callstack): + return True + return True + + def can_send_eth(self): + ''' + Must be called after slithIR analysis pass + :return: bool + ''' + return self._call_value is not None + + # endregion + ################################################################################### + ################################################################################### + # region Built in + ################################################################################### + ################################################################################### + def __str__(self): value = '' gas = '' diff --git a/slither/slithir/operations/library_call.py b/slither/slithir/operations/library_call.py index 76abfbe8a..ae3858834 100644 --- a/slither/slithir/operations/library_call.py +++ b/slither/slithir/operations/library_call.py @@ -9,6 +9,18 @@ class LibraryCall(HighLevelCall): def _check_destination(self, destination): assert isinstance(destination, (Contract)) + def can_reenter(self, callstack=None): + ''' + Must be called after slithIR analysis pass + :return: bool + ''' + # In case of recursion, return False + callstack = [] if callstack is None else callstack + if self.function in callstack: + return False + callstack = callstack + [self.function] + return self.function.can_reenter(callstack) + def __str__(self): gas = '' if self.call_gas: diff --git a/slither/slithir/operations/low_level_call.py b/slither/slithir/operations/low_level_call.py index a55482ad7..2f8f03b12 100644 --- a/slither/slithir/operations/low_level_call.py +++ b/slither/slithir/operations/low_level_call.py @@ -54,6 +54,20 @@ class LowLevelCall(Call, OperationWithLValue): # remove None return self._unroll([x for x in all_read if x]) + def can_reenter(self, callstack=None): + ''' + Must be called after slithIR analysis pass + :return: bool + ''' + return True + + def can_send_eth(self): + ''' + Must be called after slithIR analysis pass + :return: bool + ''' + return self._call_value is not None + @property def destination(self): return self._destination diff --git a/slither/slithir/operations/new_contract.py b/slither/slithir/operations/new_contract.py index 7326a659e..52060ba2b 100644 --- a/slither/slithir/operations/new_contract.py +++ b/slither/slithir/operations/new_contract.py @@ -31,16 +31,52 @@ class NewContract(Call, OperationWithLValue): def call_id(self, c): self._callid = c - @property def contract_name(self): return self._contract_name - @property def read(self): return self._unroll(self.arguments) + @property + def contract_created(self): + contract_name = self.contract_name + contract_instance = self.slither.get_contract_from_name(contract_name) + return contract_instance + + ################################################################################### + ################################################################################### + # region Analyses + ################################################################################### + ################################################################################### + + def can_reenter(self, callstack=None): + ''' + Must be called after slithIR analysis pass + For Solidity > 0.5, filter access to public variables and constant/pure/view + For call to this. check if the destination can re-enter + :param callstack: check for recursion + :return: bool + ''' + callstack = [] if callstack is None else callstack + constructor = self.contract_created.constructor + if constructor is None: + return False + if constructor in callstack: + return False + callstack = callstack + [constructor] + return constructor.can_reenter(callstack) + + def can_send_eth(self): + ''' + Must be called after slithIR analysis pass + :return: bool + ''' + return self._call_value is not None + + # endregion + def __str__(self): value = '' if self.call_value: diff --git a/slither/utils/function.py b/slither/utils/function.py index 7e142e342..a7448d48e 100644 --- a/slither/utils/function.py +++ b/slither/utils/function.py @@ -1,4 +1,3 @@ -import hashlib import sha3 def get_function_id(sig): From de4d863e193057f87b9dfb72f4b4b3c26a75dd9e Mon Sep 17 00:00:00 2001 From: Josselin Date: Mon, 12 Aug 2019 10:01:03 +0200 Subject: [PATCH 126/223] Improve solc_version information --- slither/core/slither_core.py | 3 ++ slither/solc_parsing/declarations/contract.py | 2 +- slither/solc_parsing/slitherSolc.py | 45 +++++++++---------- 3 files changed, 25 insertions(+), 25 deletions(-) diff --git a/slither/core/slither_core.py b/slither/core/slither_core.py index 2747416fd..ec1b16b28 100644 --- a/slither/core/slither_core.py +++ b/slither/core/slither_core.py @@ -77,6 +77,9 @@ class Slither(Context): @property def solc_version(self): """str: Solidity version.""" + if self.crytic_compile: + print(self.crytic_compile.compiler_version.version) + return self.crytic_compile.compiler_version.version return self._solc_version @property diff --git a/slither/solc_parsing/declarations/contract.py b/slither/solc_parsing/declarations/contract.py index eb6021966..d36e9150a 100644 --- a/slither/solc_parsing/declarations/contract.py +++ b/slither/solc_parsing/declarations/contract.py @@ -20,7 +20,7 @@ class ContractSolc04(Contract): def __init__(self, slitherSolc, data): - assert slitherSolc.solc_version.startswith('0.4') + #assert slitherSolc.solc_version.startswith('0.4') super(ContractSolc04, self).__init__() self.set_slither(slitherSolc) diff --git a/slither/solc_parsing/slitherSolc.py b/slither/solc_parsing/slitherSolc.py index 70e276f19..8a695ae6a 100644 --- a/slither/solc_parsing/slitherSolc.py +++ b/slither/solc_parsing/slitherSolc.py @@ -104,30 +104,27 @@ class SlitherSolc(Slither): return for contract_data in data_loaded[self.get_children()]: - # if self.solc_version == '0.3': - # assert contract_data[self.get_key()] == 'Contract' - # contract = ContractSolc03(self, contract_data) - if self.solc_version == '0.4': - assert contract_data[self.get_key()] in ['ContractDefinition', 'PragmaDirective', 'ImportDirective'] - if contract_data[self.get_key()] == 'ContractDefinition': - contract = ContractSolc04(self, contract_data) - if 'src' in contract_data: - contract.set_offset(contract_data['src'], self) - self._contractsNotParsed.append(contract) - elif contract_data[self.get_key()] == 'PragmaDirective': - if self._is_compact_ast: - pragma = Pragma(contract_data['literals']) - else: - pragma = Pragma(contract_data['attributes']["literals"]) - pragma.set_offset(contract_data['src'], self) - self._pragma_directives.append(pragma) - elif contract_data[self.get_key()] == 'ImportDirective': - if self.is_compact_ast: - import_directive = Import(contract_data["absolutePath"]) - else: - import_directive = Import(contract_data['attributes']["absolutePath"]) - import_directive.set_offset(contract_data['src'], self) - self._import_directives.append(import_directive) + + assert contract_data[self.get_key()] in ['ContractDefinition', 'PragmaDirective', 'ImportDirective'] + if contract_data[self.get_key()] == 'ContractDefinition': + contract = ContractSolc04(self, contract_data) + if 'src' in contract_data: + contract.set_offset(contract_data['src'], self) + self._contractsNotParsed.append(contract) + elif contract_data[self.get_key()] == 'PragmaDirective': + if self._is_compact_ast: + pragma = Pragma(contract_data['literals']) + else: + pragma = Pragma(contract_data['attributes']["literals"]) + pragma.set_offset(contract_data['src'], self) + self._pragma_directives.append(pragma) + elif contract_data[self.get_key()] == 'ImportDirective': + if self.is_compact_ast: + import_directive = Import(contract_data["absolutePath"]) + else: + import_directive = Import(contract_data['attributes']["absolutePath"]) + import_directive.set_offset(contract_data['src'], self) + self._import_directives.append(import_directive) def _parse_source_unit(self, data, filename): From 923d82acfc7ca4ac55f6db951d5c9f910b50af26 Mon Sep 17 00:00:00 2001 From: Josselin Date: Mon, 12 Aug 2019 10:07:10 +0200 Subject: [PATCH 127/223] Remove print --- slither/core/slither_core.py | 1 - 1 file changed, 1 deletion(-) diff --git a/slither/core/slither_core.py b/slither/core/slither_core.py index ec1b16b28..8106930ef 100644 --- a/slither/core/slither_core.py +++ b/slither/core/slither_core.py @@ -78,7 +78,6 @@ class Slither(Context): def solc_version(self): """str: Solidity version.""" if self.crytic_compile: - print(self.crytic_compile.compiler_version.version) return self.crytic_compile.compiler_version.version return self._solc_version From df0dacc2a931d25e70e78fffad82a3250bc86d0e Mon Sep 17 00:00:00 2001 From: Josselin Date: Tue, 13 Aug 2019 08:26:14 +0200 Subject: [PATCH 128/223] Improve constant folding --- slither/visitors/expression/constants_folding.py | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/slither/visitors/expression/constants_folding.py b/slither/visitors/expression/constants_folding.py index 60568881b..372a383b5 100644 --- a/slither/visitors/expression/constants_folding.py +++ b/slither/visitors/expression/constants_folding.py @@ -99,6 +99,13 @@ class ConstantFolding(ExpressionVisitor): raise NotConstant def _post_tuple_expression(self, expression): + if expression.expressions: + if len(expression.expressions) == 1: + cf = ConstantFolding(expression.expressions[0], self._type) + expr = cf.result() + assert isinstance(expr, Literal) + set_val(expression, int(expr.value)) + return raise NotConstant def _post_type_conversion(self, expression): From 48879668e13c1ca26b42c0b2704151ac348a6a39 Mon Sep 17 00:00:00 2001 From: Josselin Date: Wed, 14 Aug 2019 15:59:24 +0200 Subject: [PATCH 129/223] Move .utils to slither.tools to allow use in external tools --- setup.py | 6 +++--- {utils => slither/tools}/__init__.py | 0 {utils => slither/tools}/demo/README.md | 0 {utils => slither/tools}/demo/__init__.py | 0 {utils => slither/tools}/demo/__main__.py | 0 {utils => slither/tools}/possible_paths/__init__.py | 0 {utils => slither/tools}/possible_paths/__main__.py | 0 {utils => slither/tools}/possible_paths/possible_paths.py | 0 {utils => slither/tools}/similarity/__init__.py | 0 {utils => slither/tools}/similarity/__main__.py | 0 {utils => slither/tools}/similarity/cache.py | 0 {utils => slither/tools}/similarity/encode.py | 0 {utils => slither/tools}/similarity/info.py | 0 {utils => slither/tools}/similarity/model.py | 0 {utils => slither/tools}/similarity/plot.py | 0 {utils => slither/tools}/similarity/similarity.py | 0 {utils => slither/tools}/similarity/test.py | 0 {utils => slither/tools}/similarity/train.py | 0 {utils => slither/tools}/upgradeability/__init__.py | 0 {utils => slither/tools}/upgradeability/__main__.py | 0 .../tools}/upgradeability/check_initialization.py | 2 +- .../tools}/upgradeability/compare_function_ids.py | 0 .../tools}/upgradeability/compare_variables_order.py | 0 slither/tools/utils/__init__.py | 0 24 files changed, 4 insertions(+), 4 deletions(-) rename {utils => slither/tools}/__init__.py (100%) rename {utils => slither/tools}/demo/README.md (100%) rename {utils => slither/tools}/demo/__init__.py (100%) rename {utils => slither/tools}/demo/__main__.py (100%) rename {utils => slither/tools}/possible_paths/__init__.py (100%) rename {utils => slither/tools}/possible_paths/__main__.py (100%) rename {utils => slither/tools}/possible_paths/possible_paths.py (100%) rename {utils => slither/tools}/similarity/__init__.py (100%) rename {utils => slither/tools}/similarity/__main__.py (100%) rename {utils => slither/tools}/similarity/cache.py (100%) rename {utils => slither/tools}/similarity/encode.py (100%) rename {utils => slither/tools}/similarity/info.py (100%) rename {utils => slither/tools}/similarity/model.py (100%) rename {utils => slither/tools}/similarity/plot.py (100%) rename {utils => slither/tools}/similarity/similarity.py (100%) rename {utils => slither/tools}/similarity/test.py (100%) rename {utils => slither/tools}/similarity/train.py (100%) rename {utils => slither/tools}/upgradeability/__init__.py (100%) rename {utils => slither/tools}/upgradeability/__main__.py (100%) rename {utils => slither/tools}/upgradeability/check_initialization.py (99%) rename {utils => slither/tools}/upgradeability/compare_function_ids.py (100%) rename {utils => slither/tools}/upgradeability/compare_variables_order.py (100%) create mode 100644 slither/tools/utils/__init__.py diff --git a/setup.py b/setup.py index cd1248087..e013405e6 100644 --- a/setup.py +++ b/setup.py @@ -17,9 +17,9 @@ setup( entry_points={ 'console_scripts': [ 'slither = slither.__main__:main', - 'slither-check-upgradeability = utils.upgradeability.__main__:main', - 'slither-find-paths = utils.possible_paths.__main__:main', - 'slither-simil = utils.similarity.__main__:main' + 'slither-check-upgradeability = slither.tools.upgradeability.__main__:main', + 'slither-find-paths = slither.tools.possible_paths.__main__:main', + 'slither-simil = slither.tools.similarity.__main__:main' ] } ) diff --git a/utils/__init__.py b/slither/tools/__init__.py similarity index 100% rename from utils/__init__.py rename to slither/tools/__init__.py diff --git a/utils/demo/README.md b/slither/tools/demo/README.md similarity index 100% rename from utils/demo/README.md rename to slither/tools/demo/README.md diff --git a/utils/demo/__init__.py b/slither/tools/demo/__init__.py similarity index 100% rename from utils/demo/__init__.py rename to slither/tools/demo/__init__.py diff --git a/utils/demo/__main__.py b/slither/tools/demo/__main__.py similarity index 100% rename from utils/demo/__main__.py rename to slither/tools/demo/__main__.py diff --git a/utils/possible_paths/__init__.py b/slither/tools/possible_paths/__init__.py similarity index 100% rename from utils/possible_paths/__init__.py rename to slither/tools/possible_paths/__init__.py diff --git a/utils/possible_paths/__main__.py b/slither/tools/possible_paths/__main__.py similarity index 100% rename from utils/possible_paths/__main__.py rename to slither/tools/possible_paths/__main__.py diff --git a/utils/possible_paths/possible_paths.py b/slither/tools/possible_paths/possible_paths.py similarity index 100% rename from utils/possible_paths/possible_paths.py rename to slither/tools/possible_paths/possible_paths.py diff --git a/utils/similarity/__init__.py b/slither/tools/similarity/__init__.py similarity index 100% rename from utils/similarity/__init__.py rename to slither/tools/similarity/__init__.py diff --git a/utils/similarity/__main__.py b/slither/tools/similarity/__main__.py similarity index 100% rename from utils/similarity/__main__.py rename to slither/tools/similarity/__main__.py diff --git a/utils/similarity/cache.py b/slither/tools/similarity/cache.py similarity index 100% rename from utils/similarity/cache.py rename to slither/tools/similarity/cache.py diff --git a/utils/similarity/encode.py b/slither/tools/similarity/encode.py similarity index 100% rename from utils/similarity/encode.py rename to slither/tools/similarity/encode.py diff --git a/utils/similarity/info.py b/slither/tools/similarity/info.py similarity index 100% rename from utils/similarity/info.py rename to slither/tools/similarity/info.py diff --git a/utils/similarity/model.py b/slither/tools/similarity/model.py similarity index 100% rename from utils/similarity/model.py rename to slither/tools/similarity/model.py diff --git a/utils/similarity/plot.py b/slither/tools/similarity/plot.py similarity index 100% rename from utils/similarity/plot.py rename to slither/tools/similarity/plot.py diff --git a/utils/similarity/similarity.py b/slither/tools/similarity/similarity.py similarity index 100% rename from utils/similarity/similarity.py rename to slither/tools/similarity/similarity.py diff --git a/utils/similarity/test.py b/slither/tools/similarity/test.py similarity index 100% rename from utils/similarity/test.py rename to slither/tools/similarity/test.py diff --git a/utils/similarity/train.py b/slither/tools/similarity/train.py similarity index 100% rename from utils/similarity/train.py rename to slither/tools/similarity/train.py diff --git a/utils/upgradeability/__init__.py b/slither/tools/upgradeability/__init__.py similarity index 100% rename from utils/upgradeability/__init__.py rename to slither/tools/upgradeability/__init__.py diff --git a/utils/upgradeability/__main__.py b/slither/tools/upgradeability/__main__.py similarity index 100% rename from utils/upgradeability/__main__.py rename to slither/tools/upgradeability/__main__.py diff --git a/utils/upgradeability/check_initialization.py b/slither/tools/upgradeability/check_initialization.py similarity index 99% rename from utils/upgradeability/check_initialization.py rename to slither/tools/upgradeability/check_initialization.py index 22885ed31..c81d7a249 100644 --- a/utils/upgradeability/check_initialization.py +++ b/slither/tools/upgradeability/check_initialization.py @@ -11,7 +11,7 @@ class MultipleInitTarget(Exception): pass def _get_initialize_functions(contract): - return [f for f in contract.functions if f.name == 'initialize'] + return [f for f in contract.functions if f.name == 'initialize' and f.is_implemented] def _get_all_internal_calls(function): all_ir = function.all_slithir_operations() diff --git a/utils/upgradeability/compare_function_ids.py b/slither/tools/upgradeability/compare_function_ids.py similarity index 100% rename from utils/upgradeability/compare_function_ids.py rename to slither/tools/upgradeability/compare_function_ids.py diff --git a/utils/upgradeability/compare_variables_order.py b/slither/tools/upgradeability/compare_variables_order.py similarity index 100% rename from utils/upgradeability/compare_variables_order.py rename to slither/tools/upgradeability/compare_variables_order.py diff --git a/slither/tools/utils/__init__.py b/slither/tools/utils/__init__.py new file mode 100644 index 000000000..e69de29bb From accb6875445d2eae578d0ff59e6d9eddab7e9d81 Mon Sep 17 00:00:00 2001 From: Abhimanyu121 Date: Fri, 19 Jul 2019 14:31:31 +0530 Subject: [PATCH 130/223] New Printer: Prints Contructor call sequence inital commit it just gets instance of constructor of every contract following c3 linearization made proper constructor printer improved code readablity added check when there are no contructors added link to wiki updated argument to "constructor-calls" --- examples/printers/constructors.sol | 26 ++++++++++ slither/printers/all_printers.py | 1 + slither/printers/summary/constructor_calls.py | 47 +++++++++++++++++++ 3 files changed, 74 insertions(+) create mode 100644 examples/printers/constructors.sol create mode 100644 slither/printers/summary/constructor_calls.py diff --git a/examples/printers/constructors.sol b/examples/printers/constructors.sol new file mode 100644 index 000000000..845039032 --- /dev/null +++ b/examples/printers/constructors.sol @@ -0,0 +1,26 @@ +pragma solidity >=0.4.22 <0.6.0; +contract test{ + uint a; + constructor()public{ + a =5; + } + +} +contract test2 is test{ + constructor()public{ + a=10; + } +} +contract test3 is test2{ + address owner; + bytes32 name; + constructor(bytes32 _name)public{ + owner = msg.sender; + name = _name; + a=20; + } + function print() public returns(uint b){ + b=a; + + } +} \ No newline at end of file diff --git a/slither/printers/all_printers.py b/slither/printers/all_printers.py index 3c6ad58d3..25f7a3ee0 100644 --- a/slither/printers/all_printers.py +++ b/slither/printers/all_printers.py @@ -13,3 +13,4 @@ from .summary.variable_order import VariableOrder from .summary.data_depenency import DataDependency from .summary.modifier_calls import Modifiers from .summary.require_calls import RequireOrAssert +from .summary.constructor_calls import ConstructorPrinter \ No newline at end of file diff --git a/slither/printers/summary/constructor_calls.py b/slither/printers/summary/constructor_calls.py new file mode 100644 index 000000000..66e64d626 --- /dev/null +++ b/slither/printers/summary/constructor_calls.py @@ -0,0 +1,47 @@ +""" + Module printing summary of the contract +""" +from slither.printers.abstract_printer import AbstractPrinter + + + +class ConstructorPrinter(AbstractPrinter): + WIKI = 'https://github.com/crytic/slither/wiki/Printer-documentation#constructor-calls' + ARGUMENT = 'constructor-calls' + HELP = 'Print the constructors executed' + + def _get_soruce_code(self,cst): + src_mapping = cst.source_mapping + content= self.slither.source_code[src_mapping['filename_absolute']] + start = src_mapping['start'] + end = src_mapping['start'] + src_mapping['length'] + initial_space = src_mapping['starting_column'] + return ' ' * initial_space + content[start:end] + + def output(self,_filename): + for contract in self.contracts: + stack_name = [] + stack_definition = [] + print("\n\nContact Name:",contract.name) + print(" Constructor Call Sequence: ", sep=' ', end='', flush=True) + cst = contract.constructors_declared + if cst: + stack_name.append(contract.name) + stack_definition.append(self._get_soruce_code(cst)) + for inherited_contract in contract.inheritance: + cst = inherited_contract.constructors_declared + if cst: + stack_name.append(inherited_contract.name) + stack_definition.append(self._get_soruce_code(cst)) + if len(stack_name)>0: + print(" ",stack_name[len(stack_name)-1], sep=' ', end='', flush=True) + count = len(stack_name)-2; + while count>=0: + print("-->",stack_name[count], sep=' ', end='', flush=True) + count= count-1; + print("\n Constructor Definitions:") + count = len(stack_definition)-1 + while count>=0: + print("\n Contract name:", stack_name[count]) + print ("\n", stack_definition[count]) + count = count-1; From c417c04bf0c4c791924e324fd27ae04ddf6ae4d2 Mon Sep 17 00:00:00 2001 From: Josselin Date: Fri, 16 Aug 2019 17:38:44 +0200 Subject: [PATCH 131/223] v0.6.5 --- setup.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/setup.py b/setup.py index e013405e6..ae6194d6c 100644 --- a/setup.py +++ b/setup.py @@ -5,13 +5,13 @@ setup( description='Slither is a Solidity static analysis framework written in Python 3.', url='https://github.com/crytic/slither', author='Trail of Bits', - version='0.6.4', + version='0.6.5', packages=find_packages(), python_requires='>=3.6', install_requires=['prettytable>=0.7.2', 'pysha3>=1.0.2', - 'crytic-compile'], - dependency_links=['git+https://github.com/crytic/crytic-compile.git@master#egg=crytic-compile'], + 'crytic-compile>=0.1.3'], + #dependency_links=['git+https://github.com/crytic/crytic-compile.git@master#egg=crytic-compile'], license='AGPL-3.0', long_description=open('README.md').read(), entry_points={ From e2ed64c97bf8d42b89f860b95e5842d041b8a99e Mon Sep 17 00:00:00 2001 From: Josselin Date: Fri, 16 Aug 2019 19:50:09 +0200 Subject: [PATCH 132/223] Fix reentrancy detector --- slither/slithir/operations/send.py | 3 +++ slither/slithir/operations/transfer.py | 2 ++ 2 files changed, 5 insertions(+) diff --git a/slither/slithir/operations/send.py b/slither/slithir/operations/send.py index 201de989a..690459cf2 100644 --- a/slither/slithir/operations/send.py +++ b/slither/slithir/operations/send.py @@ -17,6 +17,9 @@ class Send(Call, OperationWithLValue): self._call_value = value + def can_send_eth(self): + return True + @property def call_value(self): return self._call_value diff --git a/slither/slithir/operations/transfer.py b/slither/slithir/operations/transfer.py index b334d02ce..b46d96b73 100644 --- a/slither/slithir/operations/transfer.py +++ b/slither/slithir/operations/transfer.py @@ -11,6 +11,8 @@ class Transfer(Call): self._call_value = value + def can_send_eth(self): + return True @property def call_value(self): From b43d4c92223b1c9418b374bb0a0ad72d7493e69a Mon Sep 17 00:00:00 2001 From: Josselin Date: Fri, 16 Aug 2019 20:26:24 +0200 Subject: [PATCH 133/223] v0.6.6 --- setup.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.py b/setup.py index ae6194d6c..8cb5f1f77 100644 --- a/setup.py +++ b/setup.py @@ -5,7 +5,7 @@ setup( description='Slither is a Solidity static analysis framework written in Python 3.', url='https://github.com/crytic/slither', author='Trail of Bits', - version='0.6.5', + version='0.6.6', packages=find_packages(), python_requires='>=3.6', install_requires=['prettytable>=0.7.2', From d3ba27baea26b8dd3388c8469f5943ac13b7df34 Mon Sep 17 00:00:00 2001 From: agroce Date: Tue, 20 Aug 2019 10:23:19 -0700 Subject: [PATCH 134/223] ignore naming convention restriction on echidna_ and crytic_ functions --- slither/detectors/naming_convention/naming_convention.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/slither/detectors/naming_convention/naming_convention.py b/slither/detectors/naming_convention/naming_convention.py index f1f35507c..a4237e07b 100644 --- a/slither/detectors/naming_convention/naming_convention.py +++ b/slither/detectors/naming_convention/naming_convention.py @@ -10,6 +10,7 @@ class NamingConvention(AbstractDetector): Exceptions: - Allow constant variables name/symbol/decimals to be lowercase (ERC20) - Allow '_' at the beggining of the mixed_case match for private variables and unused parameters + - Ignore echidna properties (functions with names starting 'echidna_' or 'crytic_' """ ARGUMENT = 'naming-convention' @@ -97,6 +98,8 @@ Solidity defines a [naming convention](https://solidity.readthedocs.io/en/v0.4.2 if not self.is_mixed_case(func.name): if func.visibility in ['internal', 'private'] and self.is_mixed_case_with_underscore(func.name): continue + if (func.name.find("echidna_") == 0) or (func.name.find("crytic_") == 0): + continue info = "Function '{}' ({}) is not in mixedCase\n" info = info.format(func.canonical_name, func.source_mapping_str) From 5468bc1bb1fedbbc3c32ef3d38cbed29756f18cc Mon Sep 17 00:00:00 2001 From: Alex Groce Date: Wed, 21 Aug 2019 04:42:28 -0700 Subject: [PATCH 135/223] Change to startswith --- slither/detectors/naming_convention/naming_convention.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/slither/detectors/naming_convention/naming_convention.py b/slither/detectors/naming_convention/naming_convention.py index a4237e07b..f19fad0fc 100644 --- a/slither/detectors/naming_convention/naming_convention.py +++ b/slither/detectors/naming_convention/naming_convention.py @@ -98,7 +98,7 @@ Solidity defines a [naming convention](https://solidity.readthedocs.io/en/v0.4.2 if not self.is_mixed_case(func.name): if func.visibility in ['internal', 'private'] and self.is_mixed_case_with_underscore(func.name): continue - if (func.name.find("echidna_") == 0) or (func.name.find("crytic_") == 0): + if func.name.startswith("echidna_") or func.name.startswith("crytic_"): continue info = "Function '{}' ({}) is not in mixedCase\n" info = info.format(func.canonical_name, func.source_mapping_str) From 38478ac9dae2c9bce502feb0396c0a99d6924d16 Mon Sep 17 00:00:00 2001 From: Josselin Date: Sat, 24 Aug 2019 10:12:06 +0200 Subject: [PATCH 136/223] WIP of echidna guidance printer Features: - Detect payable functions - Detect functions using assert/block.number/msg.sender/timestamp/msg.gas - Constant extraction (including binary type used) --- slither/core/declarations/function.py | 17 ++++ slither/core/variables/variable.py | 19 ++++ slither/printers/all_printers.py | 3 +- slither/printers/guidance/__init__.py | 0 slither/printers/guidance/echidna.py | 120 +++++++++++++++++++++++ slither/printers/summary/function_ids.py | 15 +-- 6 files changed, 160 insertions(+), 14 deletions(-) create mode 100644 slither/printers/guidance/__init__.py create mode 100644 slither/printers/guidance/echidna.py diff --git a/slither/core/declarations/function.py b/slither/core/declarations/function.py index 71f22ddfc..47ec663ad 100644 --- a/slither/core/declarations/function.py +++ b/slither/core/declarations/function.py @@ -113,9 +113,11 @@ class Function(ChildContract, ChildInheritance, SourceMapping): self._all_high_level_calls = None self._all_library_calls = None self._all_low_level_calls = None + self._all_solidity_calls = None self._all_state_variables_read = None self._all_solidity_variables_read = None self._all_state_variables_written = None + self._all_slithir_variables = None self._all_conditional_state_variables_read = None self._all_conditional_state_variables_read_with_loop = None self._all_conditional_solidity_variables_read = None @@ -796,6 +798,14 @@ class Function(ChildContract, ChildInheritance, SourceMapping): lambda x: x.solidity_variables_read) return self._all_solidity_variables_read + def all_slithir_variables(self): + """ recursive version of slithir_variables + """ + if self._all_slithir_variables is None: + self._all_slithir_variables = self._explore_functions( + lambda x: x.slithir_variable) + return self._all_slithir_variables + def all_expressions(self): """ recursive version of variables_read """ @@ -846,6 +856,13 @@ class Function(ChildContract, ChildInheritance, SourceMapping): self._all_library_calls = self._explore_functions(lambda x: x.library_calls) return self._all_library_calls + def all_solidity_calls(self): + """ recursive version of solidity calls + """ + if self._all_solidity_calls is None: + self._all_solidity_calls = self._explore_functions(lambda x: x.solidity_calls) + return self._all_solidity_calls + @staticmethod def _explore_func_cond_read(func, include_loop): ret = [n.state_variables_read for n in func.nodes if n.is_conditional(include_loop)] diff --git a/slither/core/variables/variable.py b/slither/core/variables/variable.py index 8b37c6da1..4d7f26e03 100644 --- a/slither/core/variables/variable.py +++ b/slither/core/variables/variable.py @@ -78,6 +78,25 @@ class Variable(SourceMapping): assert isinstance(t, (Type, list)) or t is None self._type = t + @property + def function_name(self): + ''' + Return the name of the variable as a function signature + :return: + ''' + from slither.core.solidity_types import ArrayType, MappingType + variable_getter_args = "" + if type(self.type) is ArrayType: + length = 0 + v = self + while type(v.type) is ArrayType: + length += 1 + v = v.type + variable_getter_args = ','.join(["uint256"] * length) + elif type(self.type) is MappingType: + variable_getter_args = self.type.type_from + + return f"{self.name}({variable_getter_args})" def __str__(self): return self._name diff --git a/slither/printers/all_printers.py b/slither/printers/all_printers.py index 25f7a3ee0..02f83260d 100644 --- a/slither/printers/all_printers.py +++ b/slither/printers/all_printers.py @@ -13,4 +13,5 @@ from .summary.variable_order import VariableOrder from .summary.data_depenency import DataDependency from .summary.modifier_calls import Modifiers from .summary.require_calls import RequireOrAssert -from .summary.constructor_calls import ConstructorPrinter \ No newline at end of file +from .summary.constructor_calls import ConstructorPrinter +from .guidance.echidna import Echidna \ No newline at end of file diff --git a/slither/printers/guidance/__init__.py b/slither/printers/guidance/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/slither/printers/guidance/echidna.py b/slither/printers/guidance/echidna.py new file mode 100644 index 000000000..371094db2 --- /dev/null +++ b/slither/printers/guidance/echidna.py @@ -0,0 +1,120 @@ +""" +""" + +import json +from collections import defaultdict +from slither.printers.abstract_printer import AbstractPrinter +from slither.core.declarations.solidity_variables import SolidityVariableComposed, SolidityFunction +from slither.slithir.operations.binary import Binary, BinaryType + +from slither.slithir.variables import Constant + + +def _extract_payable(slither): + ret = {} + for contract in slither.contracts: + payable_functions = [f.full_name for f in contract.functions_entry_points if f.payable] + if payable_functions: + ret[contract.name] = payable_functions + return ret + +def _extract_solidity_variable_usage(slither, sol_var): + ret = {} + for contract in slither.contracts: + functions_using_sol_var = [] + for f in contract.functions_entry_points: + for v in f.all_solidity_variables_read(): + if v == sol_var: + functions_using_sol_var.append(f.full_name) + break + if functions_using_sol_var: + ret[contract.name] = functions_using_sol_var + return ret + +def _extract_constant_functions(slither): + ret = {} + for contract in slither.contracts: + cst_functions = [f.full_name for f in contract.functions_entry_points if f.view or f.pure] + if cst_functions: + ret[contract.name] = cst_functions + return ret + +def _extract_assert(slither): + ret = {} + for contract in slither.contracts: + functions_using_assert = [] + for f in contract.functions_entry_points: + for v in f.all_solidity_calls(): + if v == SolidityFunction('assert(bool)'): + functions_using_assert.append(f.full_name) + break + if functions_using_assert: + ret[contract.name] = functions_using_assert + return ret + + +def _extract_constants(slither): + ret_cst_used = defaultdict(dict) + ret_cst_used_in_binary = defaultdict(dict) + for contract in slither.contracts: + for function in contract.functions_entry_points: + all_cst_used = [] + all_cst_used_in_binary = defaultdict(list) + for ir in function.all_slithir_operations(): + if isinstance(ir, Binary): + for r in ir.read: + if isinstance(r, Constant): + all_cst_used_in_binary[BinaryType.str(ir.type)].append(r.value) + for r in ir.read: + if isinstance(r, Constant): + all_cst_used.append(r.value) + if all_cst_used: + ret_cst_used[contract.name][function.full_name] = all_cst_used + if all_cst_used_in_binary: + ret_cst_used_in_binary[contract.name][function.full_name] = all_cst_used_in_binary + return (ret_cst_used, ret_cst_used_in_binary) + + + + +class Echidna(AbstractPrinter): + ARGUMENT = 'echidna' + HELP = 'todo' + + WIKI = 'https://github.com/trailofbits/slither/wiki/Printer-documentation#echidna' + + + def output(self, filename): + """ + Output the inheritance relation + + _filename is not used + Args: + _filename(string) + """ + + payable = _extract_payable(self.slither) + timestamp = _extract_solidity_variable_usage(self.slither, + SolidityVariableComposed('block.timestamp')) + block_number = _extract_solidity_variable_usage(self.slither, + SolidityVariableComposed('block.number')) + msg_sender = _extract_solidity_variable_usage(self.slither, + SolidityVariableComposed('msg.sender')) + msg_gas = _extract_solidity_variable_usage(self.slither, + SolidityVariableComposed('msg.gas')) + assert_usage = _extract_assert(self.slither) + cst_functions = _extract_constant_functions(self.slither) + (cst_used, cst_used_in_binary) = _extract_constants(self.slither) + + + d = {'payable': payable, + 'timestamp': timestamp, + 'block_number': block_number, + 'msg_sender': msg_sender, + 'msg_gas': msg_gas, + 'assert': assert_usage, + 'constant_functions': cst_functions, + 'constants_used': cst_used, + 'constants_used_in_binary': cst_used_in_binary} + + print(json.dumps(d, indent=4)) \ No newline at end of file diff --git a/slither/printers/summary/function_ids.py b/slither/printers/summary/function_ids.py index 169a2a318..7d6539bf1 100644 --- a/slither/printers/summary/function_ids.py +++ b/slither/printers/summary/function_ids.py @@ -4,7 +4,6 @@ import collections from prettytable import PrettyTable -from slither.core.solidity_types import ArrayType, MappingType from slither.printers.abstract_printer import AbstractPrinter from slither.utils.colors import blue, green, magenta from slither.utils.function import get_function_id @@ -32,18 +31,8 @@ class FunctionIds(AbstractPrinter): table.add_row([function.full_name, hex(get_function_id(function.full_name))]) for variable in contract.state_variables: if variable.visibility in ['public']: - variable_getter_args = "" - if type(variable.type) is ArrayType: - length = 0 - v = variable - while type(v.type) is ArrayType: - length += 1 - v = v.type - variable_getter_args = ','.join(["uint256"]*length) - elif type(variable.type) is MappingType: - variable_getter_args = variable.type.type_from - - table.add_row([f"{variable.name}({variable_getter_args})", hex(get_function_id(f"{variable.name}({variable_getter_args})"))]) + sig = variable.function_name + table.add_row([sig, hex(get_function_id(sig))]) txt += str(table) + '\n' self.info(txt) From 295f6e6672fc900e770e8451dc64aca306459461 Mon Sep 17 00:00:00 2001 From: Josselin Date: Sat, 24 Aug 2019 10:24:26 +0200 Subject: [PATCH 137/223] Improve constant function detection (add state variables) --- slither/printers/guidance/echidna.py | 1 + 1 file changed, 1 insertion(+) diff --git a/slither/printers/guidance/echidna.py b/slither/printers/guidance/echidna.py index 371094db2..ed2b79d2e 100644 --- a/slither/printers/guidance/echidna.py +++ b/slither/printers/guidance/echidna.py @@ -35,6 +35,7 @@ def _extract_constant_functions(slither): ret = {} for contract in slither.contracts: cst_functions = [f.full_name for f in contract.functions_entry_points if f.view or f.pure] + cst_functions += [v.function_name for v in contract.state_variables if v.visibility in ['public']] if cst_functions: ret[contract.name] = cst_functions return ret From abc0563f63df4565070eec6f6f7a13e2fb01684b Mon Sep 17 00:00:00 2001 From: disconnect3d Date: Mon, 26 Aug 2019 15:09:59 +0200 Subject: [PATCH 138/223] Print detectors count on Slither CLI This way we can see: ``` INFO:Slither:. analyzed (34 contracts with 38 detectors), 378 result(s) found ``` for public Slither version and more for the private one ;). --- slither/__main__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/slither/__main__.py b/slither/__main__.py index b6a80bc42..364b23543 100644 --- a/slither/__main__.py +++ b/slither/__main__.py @@ -617,7 +617,7 @@ def main_impl(all_detector_classes, all_printer_classes): if printer_classes: logger.info('%s analyzed (%d contracts)', filename, number_contracts) else: - logger.info('%s analyzed (%d contracts), %d result(s) found', filename, number_contracts, len(results)) + logger.info('%s analyzed (%d contracts with %d detectors), %d result(s) found', filename, number_contracts, len(detector_classes), len(results)) if args.ignore_return_value: return From c3bc9fe83350373cf6a76f9e164bb7b24202e431 Mon Sep 17 00:00:00 2001 From: Disconnect3d Date: Tue, 27 Aug 2019 13:12:45 +0200 Subject: [PATCH 139/223] Fix MultipleCallsInLoop wiki url --- slither/detectors/statements/calls_in_loop.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/slither/detectors/statements/calls_in_loop.py b/slither/detectors/statements/calls_in_loop.py index 27622ad4a..092003c8f 100644 --- a/slither/detectors/statements/calls_in_loop.py +++ b/slither/detectors/statements/calls_in_loop.py @@ -16,7 +16,7 @@ class MultipleCallsInLoop(AbstractDetector): IMPACT = DetectorClassification.LOW CONFIDENCE = DetectorClassification.MEDIUM - WIKI = 'https://github.com/crytic/slither/wiki/Detector-Documentation/_edit#calls-inside-a-loop' + WIKI = 'https://github.com/crytic/slither/wiki/Detector-Documentation/#calls-inside-a-loop' WIKI_TITLE = 'Calls inside a loop' From 8c80fec033d99b837bebdc790a9b006f0d59cdbb Mon Sep 17 00:00:00 2001 From: burrrata <42473928+burrrata@users.noreply.github.com> Date: Wed, 4 Sep 2019 19:02:30 -0400 Subject: [PATCH 140/223] Update README.md --- README.md | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index ec9e762b0..e4e17e992 100644 --- a/README.md +++ b/README.md @@ -104,7 +104,9 @@ Num | Printer | Description ## How to install -Slither requires Python 3.6+ and [solc](https://github.com/ethereum/solidity/), the Solidity compiler. +Slither requires Python 3.6+ and [solc](https://github.com/ethereum/solidity/), the Solidity compiler. + +If your contracts require older versions of solc, [solc-select](https://github.com/crytic/solc-select) will allow you to easily switch between Solidity compiler versions on any platform. It's like NVM, for solc. ### Using Pip From b0a83b7ad4cc6036e0697e04bab35640e26561a5 Mon Sep 17 00:00:00 2001 From: Josselin Date: Tue, 10 Sep 2019 11:32:01 +0200 Subject: [PATCH 141/223] Add slither-flat (WIP) Features: - contract flattening - export all most derived contracts, or a specific one - --convert-external: change external to public (fix: https://github.com/crytic/crytic-compile/issues/32) Missing: - etherscan API - tests Fix #253. Replace #315 --- setup.py | 3 +- slither/core/declarations/contract.py | 19 ++++++ slither/tools/flattening/__init__.py | 0 slither/tools/flattening/__main__.py | 47 +++++++++++++++ slither/tools/flattening/flattening.py | 83 ++++++++++++++++++++++++++ 5 files changed, 151 insertions(+), 1 deletion(-) create mode 100644 slither/tools/flattening/__init__.py create mode 100644 slither/tools/flattening/__main__.py create mode 100644 slither/tools/flattening/flattening.py diff --git a/setup.py b/setup.py index 8cb5f1f77..7889ab8af 100644 --- a/setup.py +++ b/setup.py @@ -19,7 +19,8 @@ setup( 'slither = slither.__main__:main', 'slither-check-upgradeability = slither.tools.upgradeability.__main__:main', 'slither-find-paths = slither.tools.possible_paths.__main__:main', - 'slither-simil = slither.tools.similarity.__main__:main' + 'slither-simil = slither.tools.similarity.__main__:main', + 'slither-flat = slither.tools.flattening.__main__:main' ] } ) diff --git a/slither/core/declarations/contract.py b/slither/core/declarations/contract.py index 545c8749e..20a8f3f8e 100644 --- a/slither/core/declarations/contract.py +++ b/slither/core/declarations/contract.py @@ -614,6 +614,25 @@ class Contract(ChildSlither, SourceMapping): all_state_variables_read = [item for sublist in all_state_variables_read for item in sublist] return list(set(all_state_variables_read)) + @property + def all_library_calls(self): + ''' + list((Contract, Function): List all of the libraries func called + ''' + all_high_level_calls = [f.all_library_calls() for f in self.functions + self.modifiers] + all_high_level_calls = [item for sublist in all_high_level_calls for item in sublist] + return list(set(all_high_level_calls)) + + @property + def all_high_level_calls(self): + ''' + list((Contract, Function|Variable)): List all of the external high level calls + ''' + all_high_level_calls = [f.all_high_level_calls() for f in self.functions + self.modifiers] + all_high_level_calls = [item for sublist in all_high_level_calls for item in sublist] + return list(set(all_high_level_calls)) + + # endregion ################################################################################### ################################################################################### diff --git a/slither/tools/flattening/__init__.py b/slither/tools/flattening/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/slither/tools/flattening/__main__.py b/slither/tools/flattening/__main__.py new file mode 100644 index 000000000..735d924a2 --- /dev/null +++ b/slither/tools/flattening/__main__.py @@ -0,0 +1,47 @@ +import argparse +import logging +from slither import Slither +from crytic_compile import cryticparser +from .flattening import Flattening + +logging.basicConfig() +logging.getLogger("Slither").setLevel(logging.INFO) +logger = logging.getLogger("Slither-flattening") +logger.setLevel(logging.INFO) + +def parse_args(): + """ + Parse the underlying arguments for the program. + :return: Returns the arguments for the program. + """ + parser = argparse.ArgumentParser(description='Contracts flattening', + usage='slither-flat filename') + + parser.add_argument('filename', + help='The filename of the contract or project to analyze.') + + parser.add_argument('--convert-external', + help='Convert external to public.', + action='store_true') + + parser.add_argument('--contract', + help='Flatten a specific contract (default: all most derived contracts).', + default=None) + + # Add default arguments from crytic-compile + cryticparser.init(parser) + + return parser.parse_args() + + +def main(): + args = parse_args() + + slither = Slither(args.filename, **vars(args)) + flat = Flattening(slither, external_to_public=args.convert_external) + + flat.export(target=args.contract) + + +if __name__ == '__main__': + main() diff --git a/slither/tools/flattening/flattening.py b/slither/tools/flattening/flattening.py new file mode 100644 index 000000000..540411cd3 --- /dev/null +++ b/slither/tools/flattening/flattening.py @@ -0,0 +1,83 @@ +from pathlib import Path +import re +import logging +from slither.exceptions import SlitherException + +logger = logging.getLogger("Slither-flattening") + +class Flattening: + + DEFAULT_EXPORT_PATH = Path('crytic-export/flattening') + + def __init__(self, slither, external_to_public=False): + self._source_codes = {} + self._slither = slither + self._external_to_public = external_to_public + + for contract in slither.contracts: + self._get_source_code(contract) + + def _get_source_code(self, contract): + src_mapping = contract.source_mapping + content = self._slither.source_code[src_mapping['filename_absolute']] + start = src_mapping['start'] + end = src_mapping['start'] + src_mapping['length'] + + if self._external_to_public: + to_patch = [] + for f in contract.functions_declared: + if f.visibility == 'external': + attributes_start = int(f.parameters_src.source_mapping['start'] + + f.parameters_src.source_mapping['length']) + attributes_end = int(f.returns_src.source_mapping['start']) + attributes = content[attributes_start:attributes_end] + regex = re.search(r'((\sexternal)\s+)|(\sexternal)$|(\)external)$', attributes) + if regex: + to_patch.append(attributes_start + regex.span()[0] + 1) + else: + raise SlitherException(f'External keyword not found {f.name} {attributes}') + to_patch.sort(reverse=True) + + print(to_patch) + content = content[start:end] + for index in to_patch: + index = index - start + content = content[:index] + 'public' + content[index + len('external'):] + else: + content = content[start:end] + + self._source_codes[contract] = content + + + def _export_contract(self, contract, exported, list_contract): + if contract.name in exported: + return + for inherited in contract.inheritance: + self._export_contract(inherited, exported, list_contract) + + externals = contract.all_library_calls + contract.all_high_level_calls + # externals is a list of (contract, function) + # We also filter call to itself to avoid infilite loop + externals = list(set([e[0] for e in externals if e[0] != contract])) + + for inherited in externals: + self._export_contract(inherited, exported, list_contract) + + exported.add(contract.name) + list_contract.append(self._source_codes[contract]) + + + def export(self, target=None): + + if not self.DEFAULT_EXPORT_PATH.exists(): + self.DEFAULT_EXPORT_PATH.mkdir(parents=True) + + if target is None: + for contract in self._slither.contracts_derived: + ret = [] + self._export_contract(contract, set(), ret) + path = Path(self.DEFAULT_EXPORT_PATH, f'{contract.name}.sol') + logger.info(f'Export {path}') + with open(path, 'w') as f: + f.write('\n'.join(ret)) + f.write('\n') From 18b2bbd8a7ba975acd9cd0a9b5f41877f2176647 Mon Sep 17 00:00:00 2001 From: Feist Josselin Date: Tue, 10 Sep 2019 11:39:58 +0200 Subject: [PATCH 142/223] Update README.md --- README.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index e4e17e992..846b8c6eb 100644 --- a/README.md +++ b/README.md @@ -31,7 +31,9 @@ Run Slither on a single file: $ slither tests/uninitialized.sol ``` -For additional configuration, see the [usage](https://github.com/trailofbits/slither/wiki/Usage) documentation. +For additional configuration, see the [usage](https://github.com/trailofbits/slither/wiki/Usage) documentation. + +Use [solc-select](https://github.com/crytic/solc-select) if your contracts require older versions of solc. ## Detectors @@ -106,8 +108,6 @@ Num | Printer | Description Slither requires Python 3.6+ and [solc](https://github.com/ethereum/solidity/), the Solidity compiler. -If your contracts require older versions of solc, [solc-select](https://github.com/crytic/solc-select) will allow you to easily switch between Solidity compiler versions on any platform. It's like NVM, for solc. - ### Using Pip ``` From 1450d602bfe3872833acea77dfcbff68e142be2a Mon Sep 17 00:00:00 2001 From: Josselin Date: Tue, 10 Sep 2019 13:15:21 +0200 Subject: [PATCH 143/223] Minor --- setup.py | 2 +- slither/tools/slither_format/slither_format.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/setup.py b/setup.py index 921510d17..d385d97df 100644 --- a/setup.py +++ b/setup.py @@ -16,7 +16,7 @@ setup( 'slither = slither.__main__:main', 'slither-check-upgradeability = slither.tools.upgradeability.__main__:main', 'slither-find-paths = slither.tools.possible_paths.__main__:main', - 'slither-simil = slither.tools.similarity.__main__:main' + 'slither-simil = slither.tools.similarity.__main__:main', 'slither-format = slither.tools.slither_format.__main__:main' ] } diff --git a/slither/tools/slither_format/slither_format.py b/slither/tools/slither_format/slither_format.py index 1e024e774..fe97ed82c 100644 --- a/slither/tools/slither_format/slither_format.py +++ b/slither/tools/slither_format/slither_format.py @@ -131,7 +131,7 @@ def apply_detector_results(slither, detector_results): else: raise FormatError(result['check'] + "detector not supported yet.") except FormatImpossible as e: - logger.info(f'Impossible to patch:\n{result["description"]}\nReason: {e}') + logger.info(f'\nImpossible to patch:\n\t{result["description"]}\t{e}') # endregion From 3a5c284c90cdaea587366bcdd9dade9b45ef5a58 Mon Sep 17 00:00:00 2001 From: Josselin Date: Tue, 10 Sep 2019 13:33:27 +0200 Subject: [PATCH 144/223] Update to new ModifierStatement format --- .../tools/slither_format/formatters/naming_convention.py | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/slither/tools/slither_format/formatters/naming_convention.py b/slither/tools/slither_format/formatters/naming_convention.py index 94b6197af..4725c2d94 100644 --- a/slither/tools/slither_format/formatters/naming_convention.py +++ b/slither/tools/slither_format/formatters/naming_convention.py @@ -321,9 +321,13 @@ def _explore_variables_declaration(slither, variables, result, target, convert): def _explore_modifiers_calls(slither, function, result, target, convert): for modifier in function.modifiers_statements: - _explore_irs(slither, modifier.node.irs, result, target, convert) + for node in modifier.nodes: + if node.irs: + _explore_irs(slither, node.irs, result, target, convert) for modifier in function.explicit_base_constructor_calls_statements: - _explore_irs(slither, modifier.node.irs, result, target, convert) + for node in modifier.nodes: + if node.irs: + _explore_irs(slither, node.irs, result, target, convert) def _explore_structures_declaration(slither, structures, result, target, convert): for st in structures: From cf7d0c73ed5c7736f59ac6243e1d98c3fabd42f5 Mon Sep 17 00:00:00 2001 From: Josselin Date: Tue, 10 Sep 2019 13:55:03 +0200 Subject: [PATCH 145/223] Fix incorrect for(;;) parsing if break is present --- slither/solc_parsing/declarations/function.py | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/slither/solc_parsing/declarations/function.py b/slither/solc_parsing/declarations/function.py index 9ec13cef8..15b222989 100644 --- a/slither/solc_parsing/declarations/function.py +++ b/slither/solc_parsing/declarations/function.py @@ -824,7 +824,12 @@ class FunctionSolc(Function): end_node = self._find_end_loop(node, [], 0) if not end_node: - raise ParsingError('Break in no-loop context {}'.format(node)) + # If there is not end condition on the loop + # The exploration will reach a STARTLOOP before reaching the endloop + # We start with -1 as counter to catch this corner case + end_node = self._find_end_loop(node, [], -1) + if not end_node: + raise ParsingError('Break in no-loop context {}'.format(node.function)) for son in node.sons: son.remove_father(node) From e6a1d6324a9ec59d6f81d641761b44fd29aecad6 Mon Sep 17 00:00:00 2001 From: Josselin Date: Tue, 10 Sep 2019 14:50:19 +0200 Subject: [PATCH 146/223] Improve flattening --- slither/tools/flattening/flattening.py | 81 +++++++++++++++++++++++--- 1 file changed, 72 insertions(+), 9 deletions(-) diff --git a/slither/tools/flattening/flattening.py b/slither/tools/flattening/flattening.py index 540411cd3..2f6a2ecd5 100644 --- a/slither/tools/flattening/flattening.py +++ b/slither/tools/flattening/flattening.py @@ -2,6 +2,11 @@ from pathlib import Path import re import logging from slither.exceptions import SlitherException +from slither.core.solidity_types.user_defined_type import UserDefinedType +from slither.core.declarations.structure import Structure +from slither.core.declarations.enum import Enum +from slither.core.declarations.contract import Contract +from slither.slithir.operations import NewContract, TypeConversion logger = logging.getLogger("Slither-flattening") @@ -13,48 +18,85 @@ class Flattening: self._source_codes = {} self._slither = slither self._external_to_public = external_to_public + self._use_abi_encoder_v2 = False + + self._check_abi_encoder_v2() for contract in slither.contracts: self._get_source_code(contract) + def _check_abi_encoder_v2(self): + for p in self._slither.pragma_directives: + if 'ABIEncoderV2' in str(p.directive): + self._use_abi_encoder_v2 = True + return + def _get_source_code(self, contract): src_mapping = contract.source_mapping content = self._slither.source_code[src_mapping['filename_absolute']] start = src_mapping['start'] end = src_mapping['start'] + src_mapping['length'] - if self._external_to_public: + # interface must use external + if self._external_to_public and contract.contract_kind != "interface": + # to_patch is a list of (index, bool). The bool indicates + # if the index is for external -> public (true) + # or a calldata -> memory (false) to_patch = [] for f in contract.functions_declared: + # fallback must be external + if f.is_fallback or f.is_constructor_variables: + continue if f.visibility == 'external': - attributes_start = int(f.parameters_src.source_mapping['start'] + - f.parameters_src.source_mapping['length']) - attributes_end = int(f.returns_src.source_mapping['start']) + attributes_start = (f.parameters_src.source_mapping['start'] + + f.parameters_src.source_mapping['length']) + attributes_end = f.returns_src.source_mapping['start'] attributes = content[attributes_start:attributes_end] regex = re.search(r'((\sexternal)\s+)|(\sexternal)$|(\)external)$', attributes) if regex: - to_patch.append(attributes_start + regex.span()[0] + 1) + to_patch.append((attributes_start + regex.span()[0] + 1, True)) else: raise SlitherException(f'External keyword not found {f.name} {attributes}') - to_patch.sort(reverse=True) - print(to_patch) + for var in f.parameters: + if var.location == "calldata": + calldata_start = var.source_mapping['start'] + calldata_end = calldata_start + var.source_mapping['length'] + calldata_idx = content[calldata_start:calldata_end].find(' calldata ') + to_patch.append((calldata_start + calldata_idx + 1, False)) + + to_patch.sort(key=lambda x:x[0], reverse=True) + content = content[start:end] - for index in to_patch: + for (index, is_external) in to_patch: index = index - start - content = content[:index] + 'public' + content[index + len('external'):] + if is_external: + content = content[:index] + 'public' + content[index + len('external'):] + else: + content = content[:index] + 'memory' + content[index + len('calldata'):] else: content = content[start:end] self._source_codes[contract] = content + def _export_from_type(self, t, contract, exported, list_contract): + if isinstance(t, UserDefinedType): + if isinstance(t.type, (Enum, Structure)): + if t.type.contract != contract and not t.type.contract in exported: + self._export_contract(t.type.contract, exported, list_contract) + else: + assert isinstance(t.type, Contract) + if t.type != contract and not t.type in exported: + self._export_contract(t.type, exported, list_contract) + def _export_contract(self, contract, exported, list_contract): if contract.name in exported: return for inherited in contract.inheritance: self._export_contract(inherited, exported, list_contract) + # Find all the external contracts called externals = contract.all_library_calls + contract.all_high_level_calls # externals is a list of (contract, function) # We also filter call to itself to avoid infilite loop @@ -63,6 +105,23 @@ class Flattening: for inherited in externals: self._export_contract(inherited, exported, list_contract) + # Find all the external contracts use as a base type + local_vars = [] + for f in contract.functions_declared: + local_vars += f.variables + + for v in contract.variables + local_vars: + self._export_from_type(v.type, contract, exported, list_contract) + + # Find all convert and "new" operation that can lead to use an external contract + for f in contract.functions_declared: + for ir in f.slithir_operations: + if isinstance(ir, NewContract): + if ir.contract_created != contract and not ir.contract_created in exported: + self._export_contract(ir.contract_created, exported, list_contract) + if isinstance(ir, TypeConversion): + self._export_from_type(ir.type, contract, exported, list_contract) + exported.add(contract.name) list_contract.append(self._source_codes[contract]) @@ -79,5 +138,9 @@ class Flattening: path = Path(self.DEFAULT_EXPORT_PATH, f'{contract.name}.sol') logger.info(f'Export {path}') with open(path, 'w') as f: + if self._slither.solc_version: + f.write(f'pragma solidity {self._slither.solc_version};\n') + if self._use_abi_encoder_v2: + f.write('pragma experimental ABIEncoderV2;\n') f.write('\n'.join(ret)) f.write('\n') From 08c7d352447ff2ac02d47b3f577e8c08fe2e493f Mon Sep 17 00:00:00 2001 From: Josselin Date: Tue, 10 Sep 2019 15:57:19 +0200 Subject: [PATCH 147/223] Naming convetion: filter solidity keywords --- .../formatters/naming_convention.py | 22 ++++++++++++++++++- 1 file changed, 21 insertions(+), 1 deletion(-) diff --git a/slither/tools/slither_format/formatters/naming_convention.py b/slither/tools/slither_format/formatters/naming_convention.py index 4725c2d94..988125981 100644 --- a/slither/tools/slither_format/formatters/naming_convention.py +++ b/slither/tools/slither_format/formatters/naming_convention.py @@ -5,6 +5,7 @@ from slither.slithir.operations import Send, Transfer, OperationWithLValue, High from slither.core.declarations import Modifier from slither.core.solidity_types import UserDefinedType, MappingType from slither.core.declarations import Enum, Contract, Structure +from slither.core.solidity_types.elementary_type import ElementaryTypeName from ..exceptions import FormatError, FormatImpossible from ..utils.patches import create_patch @@ -32,9 +33,21 @@ def format(slither, result): ################################################################################### ################################################################################### - KEY = 'ALL_NAMES_USED' +# https://solidity.readthedocs.io/en/v0.5.11/miscellaneous.html#reserved-keywords +SOLIDITY_KEYWORDS = ['abstract', 'after', 'alias', 'apply', 'auto', 'case', 'catch', 'copyof', 'default', 'define', + 'final', 'immutable', 'implements', 'in', 'inline', 'let', 'macro', 'match', 'mutable', 'null', + 'of', 'override', 'partial', 'promise', 'reference', 'relocatable', 'sealed', 'sizeof', 'static', + 'supports', 'switch', 'try', 'typedef', 'typeof', 'unchecked'] + +# https://solidity.readthedocs.io/en/v0.5.11/miscellaneous.html#language-grammar +SOLIDITY_KEYWORDS += ['pragma', 'import', 'contract', 'library', 'contract', 'function', 'using', 'struct', 'enum', + 'public', 'private', 'internal', 'external', 'calldata', 'memory', 'modifier', 'view', 'pure', + 'constant', 'storage', 'for', 'if', 'while', 'break', 'return', 'throw', 'else'] + +SOLIDITY_KEYWORDS += ElementaryTypeName + def _name_already_use(slither, name): # Do not convert to a name used somewhere else if not KEY in slither.context: @@ -61,6 +74,9 @@ def _convert_CapWords(original_name, slither): if _name_already_use(slither, name): raise FormatImpossible(f'{original_name} cannot be converted to {name} (already used)') + + if name in SOLIDITY_KEYWORDS: + raise FormatImpossible(f'{original_name} cannot be converted to {name} (Solidity keyword)') return name def _convert_mixedCase(original_name, slither): @@ -74,11 +90,15 @@ def _convert_mixedCase(original_name, slither): name = name[0].lower() + name[1:] if _name_already_use(slither, name): raise FormatImpossible(f'{original_name} cannot be converted to {name} (already used)') + if name in SOLIDITY_KEYWORDS: + raise FormatImpossible(f'{original_name} cannot be converted to {name} (Solidity keyword)') return name def _convert_UPPER_CASE_WITH_UNDERSCORES(name, slither): if _name_already_use(slither, name.upper()): raise FormatImpossible(f'{name} cannot be converted to {name.upper()} (already used)') + if name.upper() in SOLIDITY_KEYWORDS: + raise FormatImpossible(f'{name} cannot be converted to {name.upper()} (Solidity keyword)') return name.upper() conventions ={ From f029eddb9930ae34e7b350b443eb8ddac89b049c Mon Sep 17 00:00:00 2001 From: Josselin Date: Tue, 10 Sep 2019 16:11:10 +0200 Subject: [PATCH 148/223] Add missing solidity keywords --- slither/tools/slither_format/formatters/naming_convention.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/slither/tools/slither_format/formatters/naming_convention.py b/slither/tools/slither_format/formatters/naming_convention.py index 988125981..ab14e98f3 100644 --- a/slither/tools/slither_format/formatters/naming_convention.py +++ b/slither/tools/slither_format/formatters/naming_convention.py @@ -44,7 +44,7 @@ SOLIDITY_KEYWORDS = ['abstract', 'after', 'alias', 'apply', 'auto', 'case', 'cat # https://solidity.readthedocs.io/en/v0.5.11/miscellaneous.html#language-grammar SOLIDITY_KEYWORDS += ['pragma', 'import', 'contract', 'library', 'contract', 'function', 'using', 'struct', 'enum', 'public', 'private', 'internal', 'external', 'calldata', 'memory', 'modifier', 'view', 'pure', - 'constant', 'storage', 'for', 'if', 'while', 'break', 'return', 'throw', 'else'] + 'constant', 'storage', 'for', 'if', 'while', 'break', 'return', 'throw', 'else', 'type'] SOLIDITY_KEYWORDS += ElementaryTypeName From b4165de2d47cb1608adabeee2470249d319835db Mon Sep 17 00:00:00 2001 From: kaisaf <10202018+kaisaf@users.noreply.github.com> Date: Tue, 10 Sep 2019 16:56:27 -0400 Subject: [PATCH 149/223] Add optimization impact level to human summary --- slither/printers/summary/human_summary.py | 13 ++++++++++--- slither/slither.py | 4 ++++ 2 files changed, 14 insertions(+), 3 deletions(-) diff --git a/slither/printers/summary/human_summary.py b/slither/printers/summary/human_summary.py index 2e126f8a3..d83fbb759 100644 --- a/slither/printers/summary/human_summary.py +++ b/slither/printers/summary/human_summary.py @@ -66,11 +66,16 @@ class PrinterHumanSummary(AbstractPrinter): logger = logging.getLogger('Detectors') logger.setLevel(logging.ERROR) + checks_optimization = self.slither.detectors_optimization checks_informational = self.slither.detectors_informational checks_low = self.slither.detectors_low checks_medium = self.slither.detectors_medium checks_high = self.slither.detectors_high + issues_optimization = [c.detect() for c in checks_optimization] + issues_optimization = [c for c in issues_optimization if c] + issues_optimization = [item for sublist in issues_optimization for item in sublist] + issues_informational = [c.detect() for c in checks_informational] issues_informational = [c for c in issues_informational if c] issues_informational = [item for sublist in issues_informational for item in sublist] @@ -89,14 +94,16 @@ class PrinterHumanSummary(AbstractPrinter): - return (len(issues_informational), + return (len(issues_optimization), + len(issues_informational), len(issues_low), len(issues_medium), len(issues_high)) def get_detectors_result(self): - issues_informational, issues_low, issues_medium, issues_high = self._get_detectors_result() - txt = "Number of informational issues: {}\n".format(green(issues_informational)) + issues_optimization, issues_informational, issues_low, issues_medium, issues_high = self._get_detectors_result() + txt = "Number of optimization issues: {}\n".format(green(issues_optimization)) + txt += "Number of informational issues: {}\n".format(green(issues_informational)) txt += "Number of low issues: {}\n".format(green(issues_low)) if issues_medium > 0: txt += "Number of medium issues: {}\n".format(yellow(issues_medium)) diff --git a/slither/slither.py b/slither/slither.py index 9a7732404..1152a7ddb 100644 --- a/slither/slither.py +++ b/slither/slither.py @@ -122,6 +122,10 @@ class Slither(SlitherSolc): def detectors_informational(self): return [d for d in self.detectors if d.IMPACT == DetectorClassification.INFORMATIONAL] + @property + def detectors_optimization(self): + return [d for d in self.detectors if d.IMPACT == DetectorClassification.OPTIMIZATION] + def register_detector(self, detector_class): """ :param detector_class: Class inheriting from `AbstractDetector`. From 41201fe3d56d4ccdf634c93e4b74956ad22c0295 Mon Sep 17 00:00:00 2001 From: Josselin Date: Wed, 11 Sep 2019 07:39:51 +0200 Subject: [PATCH 150/223] Consistent str<->bytes usage --- slither/core/slither_core.py | 2 +- .../formatters/constable_states.py | 4 +-- .../formatters/constant_function.py | 2 +- .../formatters/external_function.py | 2 +- .../formatters/naming_convention.py | 28 +++++++++---------- .../tools/slither_format/formatters/pragma.py | 4 +-- .../slither_format/formatters/solc_version.py | 4 +-- .../slither_format/formatters/unused_state.py | 2 +- .../tools/slither_format/slither_format.py | 2 +- slither/tools/slither_format/utils/patches.py | 8 ++++-- 10 files changed, 31 insertions(+), 27 deletions(-) diff --git a/slither/core/slither_core.py b/slither/core/slither_core.py index 8106930ef..f5fc88278 100644 --- a/slither/core/slither_core.py +++ b/slither/core/slither_core.py @@ -44,7 +44,7 @@ class Slither(Context): @property def source_code(self): - """ {filename: source_code}: source code """ + """ {filename: source_code (str)}: source code """ return self._raw_source_code @property diff --git a/slither/tools/slither_format/formatters/constable_states.py b/slither/tools/slither_format/formatters/constable_states.py index f07dd8c3a..67f51536f 100644 --- a/slither/tools/slither_format/formatters/constable_states.py +++ b/slither/tools/slither_format/formatters/constable_states.py @@ -13,7 +13,7 @@ def format(slither, result): def _patch(slither, result, in_file, match_text, replace_text, modify_loc_start, modify_loc_end): - in_file_str = slither.source_code[in_file].encode('utf-8') + in_file_str = slither.source_code[in_file].encode('utf8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] # Add keyword `constant` before the variable name (new_str_of_interest, num_repl) = re.subn(match_text, replace_text, old_str_of_interest.decode('utf-8'), 1) @@ -22,7 +22,7 @@ def _patch(slither, result, in_file, match_text, replace_text, modify_loc_start, in_file, modify_loc_start, modify_loc_end, - old_str_of_interest.decode('utf-8'), + old_str_of_interest, new_str_of_interest) else: diff --git a/slither/tools/slither_format/formatters/constant_function.py b/slither/tools/slither_format/formatters/constant_function.py index 23939acbc..02b09fa6a 100644 --- a/slither/tools/slither_format/formatters/constant_function.py +++ b/slither/tools/slither_format/formatters/constant_function.py @@ -20,7 +20,7 @@ def format(slither, patches, elements): def _patch(slither, patches, in_file, in_file_relative, modify_loc_start, modify_loc_end): - in_file_str = slither.source_code[in_file].encode('utf-8') + in_file_str = slither.source_code[in_file].encode('utf8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] # Find the keywords view|pure|constant and remove them m = re.search("(view|pure|constant)", old_str_of_interest.decode('utf-8')) diff --git a/slither/tools/slither_format/formatters/external_function.py b/slither/tools/slither_format/formatters/external_function.py index ec5e160f8..b3f999a41 100644 --- a/slither/tools/slither_format/formatters/external_function.py +++ b/slither/tools/slither_format/formatters/external_function.py @@ -16,7 +16,7 @@ def format(slither, result): def _patch(slither, result, in_file, modify_loc_start, modify_loc_end): - in_file_str = slither.source_code[in_file].encode('utf-8') + in_file_str = slither.source_code[in_file].encode('utf8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] # Search for 'public' keyword which is in-between the function name and modifier name (if present) # regex: 'public' could have spaces around or be at the end of the line diff --git a/slither/tools/slither_format/formatters/naming_convention.py b/slither/tools/slither_format/formatters/naming_convention.py index ab14e98f3..b56b99f92 100644 --- a/slither/tools/slither_format/formatters/naming_convention.py +++ b/slither/tools/slither_format/formatters/naming_convention.py @@ -81,7 +81,7 @@ def _convert_CapWords(original_name, slither): def _convert_mixedCase(original_name, slither): - name = original_name + name = str(original_name) while '_' in name: offset = name.find('_') if len(name) > offset: @@ -192,9 +192,9 @@ def _patch(slither, result, element, _target): # group 2: beginning of the to type # nested mapping are within the group 1 #RE_MAPPING = '[ ]*mapping[ ]*\([ ]*([\=\>\(\) a-zA-Z0-9\._\[\]]*)[ ]*=>[ ]*([a-zA-Z0-9\._\[\]]*)\)' -RE_MAPPING_FROM = '([a-zA-Z0-9\._\[\]]*)' -RE_MAPPING_TO = '([\=\>\(\) a-zA-Z0-9\._\[\]\ ]*)' -RE_MAPPING = '[ ]*mapping[ ]*\([ ]*' + RE_MAPPING_FROM + '[ ]*' + '=>' + '[ ]*'+ RE_MAPPING_TO + '\)' +RE_MAPPING_FROM = b'([a-zA-Z0-9\._\[\]]*)' +RE_MAPPING_TO = b'([\=\>\(\) a-zA-Z0-9\._\[\]\ ]*)' +RE_MAPPING = b'[ ]*mapping[ ]*\([ ]*' + RE_MAPPING_FROM + b'[ ]*' + b'=>' + b'[ ]*'+ RE_MAPPING_TO + b'\)' def _explore_type(slither, result, target, convert, type, filename_source_code, start, end): if isinstance(type, UserDefinedType): @@ -253,7 +253,7 @@ def _explore_type(slither, result, target, convert, type, filename_source_code, full_txt_start = start full_txt_end = end - full_txt = slither.source_code[filename_source_code][full_txt_start:full_txt_end] + full_txt = slither.source_code[filename_source_code].encode('utf8')[full_txt_start:full_txt_end] re_match = re.match(RE_MAPPING, full_txt) assert re_match @@ -306,7 +306,7 @@ def _explore_variables_declaration(slither, variables, result, target, convert): filename_source_code = variable.source_mapping['filename_absolute'] full_txt_start = variable.source_mapping['start'] full_txt_end = full_txt_start + variable.source_mapping['length'] - full_txt = slither.source_code[filename_source_code][full_txt_start:full_txt_end] + full_txt = slither.source_code[filename_source_code].encode('utf8')[full_txt_start:full_txt_end] _explore_type(slither, result, @@ -326,7 +326,7 @@ def _explore_variables_declaration(slither, variables, result, target, convert): # We take all the space, as we dont know the type # In comparison to other matches, it is ok as there will not be more than one # 'spaces' zone (ex: for function, the body and the signature will also contain space) - matches = re.finditer('[ ]*', full_txt) + matches = re.finditer(b'[ ]*', full_txt) # Look for the end offset of the largest list of ' ' loc_start = full_txt_start + max(matches, key=lambda x:len(x.group())).end() loc_end = loc_start + len(old_str) @@ -362,7 +362,7 @@ def _explore_structures_declaration(slither, structures, result, target, convert filename_source_code = st.source_mapping['filename_absolute'] full_txt_start = st.source_mapping['start'] full_txt_end = full_txt_start + st.source_mapping['length'] - full_txt = slither.source_code[filename_source_code][full_txt_start:full_txt_end] + full_txt = slither.source_code[filename_source_code].encode('utf8')[full_txt_start:full_txt_end] # The name is after the space matches = re.finditer('struct[ ]*', full_txt) @@ -427,12 +427,12 @@ def _explore_irs(slither, irs, result, target, convert): filename_source_code = source_mapping['filename_absolute'] full_txt_start = source_mapping['start'] full_txt_end = full_txt_start + source_mapping['length'] - full_txt = slither.source_code[filename_source_code][full_txt_start:full_txt_end] + full_txt = slither.source_code[filename_source_code].encode('utf8')[full_txt_start:full_txt_end] - if not str(target) in full_txt: + if not target.name.encode('utf8') in full_txt: raise FormatError(f'{target} not found in {full_txt} ({source_mapping}') - old_str = str(target) + old_str = target.name.encode('utf8') new_str = convert(old_str, slither) counter = 0 @@ -469,7 +469,7 @@ def _explore_functions(slither, functions, result, target, convert): filename_source_code = function.source_mapping['filename_absolute'] full_txt_start = function.source_mapping['start'] full_txt_end = full_txt_start + function.source_mapping['length'] - full_txt = slither.source_code[filename_source_code][full_txt_start:full_txt_end] + full_txt = slither.source_code[filename_source_code].encode('utf8')[full_txt_start:full_txt_end] # The name is after the space if isinstance(target, Modifier): @@ -497,7 +497,7 @@ def _explore_enums(slither, enums, result, target, convert): filename_source_code = enum.source_mapping['filename_absolute'] full_txt_start = enum.source_mapping['start'] full_txt_end = full_txt_start + enum.source_mapping['length'] - full_txt = slither.source_code[filename_source_code][full_txt_start:full_txt_end] + full_txt = slither.source_code[filename_source_code].encode('utf8')[full_txt_start:full_txt_end] # The name is after the space matches = re.finditer('enum([ ]*)', full_txt) @@ -523,7 +523,7 @@ def _explore_contract(slither, contract, result, target, convert): filename_source_code = contract.source_mapping['filename_absolute'] full_txt_start = contract.source_mapping['start'] full_txt_end = full_txt_start + contract.source_mapping['length'] - full_txt = slither.source_code[filename_source_code][full_txt_start:full_txt_end] + full_txt = slither.source_code[filename_source_code].encode('utf8')[full_txt_start:full_txt_end] old_str = contract.name new_str = convert(old_str, slither) diff --git a/slither/tools/slither_format/formatters/pragma.py b/slither/tools/slither_format/formatters/pragma.py index 57f01b3c9..5f8d65ede 100644 --- a/slither/tools/slither_format/formatters/pragma.py +++ b/slither/tools/slither_format/formatters/pragma.py @@ -59,11 +59,11 @@ def _determine_solc_version_replacement(used_solc_version): def _patch(slither, result, in_file, pragma, modify_loc_start, modify_loc_end): - in_file_str = slither.source_code[in_file].encode('utf-8') + in_file_str = slither.source_code[in_file].encode('utf8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] create_patch(result, in_file, int(modify_loc_start), int(modify_loc_end), - old_str_of_interest.decode('utf-8'), + old_str_of_interest, pragma) diff --git a/slither/tools/slither_format/formatters/solc_version.py b/slither/tools/slither_format/formatters/solc_version.py index fe7b3fe27..fbc3cace2 100644 --- a/slither/tools/slither_format/formatters/solc_version.py +++ b/slither/tools/slither_format/formatters/solc_version.py @@ -49,11 +49,11 @@ def _determine_solc_version_replacement(used_solc_version): def _patch(slither, result, in_file, solc_version, modify_loc_start, modify_loc_end): - in_file_str = slither.source_code[in_file].encode('utf-8') + in_file_str = slither.source_code[in_file].encode('utf8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] create_patch(result, in_file, int(modify_loc_start), int(modify_loc_end), - old_str_of_interest.decode('utf-8'), + old_str_of_interest, solc_version) diff --git a/slither/tools/slither_format/formatters/unused_state.py b/slither/tools/slither_format/formatters/unused_state.py index 2bb3abee1..0e0f30bde 100644 --- a/slither/tools/slither_format/formatters/unused_state.py +++ b/slither/tools/slither_format/formatters/unused_state.py @@ -12,7 +12,7 @@ def format(slither, result): def _patch(slither, result, in_file, modify_loc_start): - in_file_str = slither.source_code[in_file].encode('utf-8') + in_file_str = slither.source_code[in_file].encode('utf8') old_str_of_interest = in_file_str[modify_loc_start:] old_str = old_str_of_interest.decode('utf-8').partition(';')[0]\ + old_str_of_interest.decode('utf-8').partition(';')[1] diff --git a/slither/tools/slither_format/slither_format.py b/slither/tools/slither_format/slither_format.py index fe97ed82c..01cf1ee19 100644 --- a/slither/tools/slither_format/slither_format.py +++ b/slither/tools/slither_format/slither_format.py @@ -57,7 +57,7 @@ def slither_format(slither, **kwargs): logger.info(f'Issue: {one_line_description}') logger.info('Generated:') for file in result['patches']: - original_txt = slither.source_code[file] + original_txt = slither.source_code[file].encode('utf8') patched_txt = original_txt offset = 0 patches = result['patches'][file] diff --git a/slither/tools/slither_format/utils/patches.py b/slither/tools/slither_format/utils/patches.py index a8fb48d11..dc8414bd4 100644 --- a/slither/tools/slither_format/utils/patches.py +++ b/slither/tools/slither_format/utils/patches.py @@ -3,6 +3,10 @@ import difflib from collections import defaultdict def create_patch(result, file, start, end, old_str, new_str): + if isinstance(old_str, str): + old_str = old_str.encode('utf8') + if isinstance(new_str, str): + new_str = new_str.encode('utf8') p = {"start": start, "end": end, "old_string": old_str, @@ -30,8 +34,8 @@ def create_diff(slither, original_txt, patched_txt, filename): relative_path = os.path.join('.', relative_path) else: relative_path = filename - diff = difflib.unified_diff(original_txt.splitlines(False), - patched_txt.splitlines(False), + diff = difflib.unified_diff(original_txt.decode('utf8').splitlines(False), + patched_txt.decode('utf8').splitlines(False), fromfile=relative_path, tofile=relative_path, lineterm='') From 24dc3797d2304b4c2e4cef2e62e226d087a1fad3 Mon Sep 17 00:00:00 2001 From: Josselin Date: Wed, 11 Sep 2019 08:39:44 +0200 Subject: [PATCH 151/223] Minor --- slither/tools/slither_format/formatters/naming_convention.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/slither/tools/slither_format/formatters/naming_convention.py b/slither/tools/slither_format/formatters/naming_convention.py index b56b99f92..e5f312fbe 100644 --- a/slither/tools/slither_format/formatters/naming_convention.py +++ b/slither/tools/slither_format/formatters/naming_convention.py @@ -80,8 +80,10 @@ def _convert_CapWords(original_name, slither): return name def _convert_mixedCase(original_name, slither): + name = original_name + if isinstance(name, bytes): + name = name.decode('utf8') - name = str(original_name) while '_' in name: offset = name.find('_') if len(name) > offset: From 13f4066c05b94df76581328a992070ea57a84848 Mon Sep 17 00:00:00 2001 From: Josselin Date: Wed, 11 Sep 2019 08:47:02 +0200 Subject: [PATCH 152/223] Minor --- .../slither_format/formatters/naming_convention.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/slither/tools/slither_format/formatters/naming_convention.py b/slither/tools/slither_format/formatters/naming_convention.py index e5f312fbe..4a40f58a3 100644 --- a/slither/tools/slither_format/formatters/naming_convention.py +++ b/slither/tools/slither_format/formatters/naming_convention.py @@ -367,7 +367,7 @@ def _explore_structures_declaration(slither, structures, result, target, convert full_txt = slither.source_code[filename_source_code].encode('utf8')[full_txt_start:full_txt_end] # The name is after the space - matches = re.finditer('struct[ ]*', full_txt) + matches = re.finditer(b'struct[ ]*', full_txt) # Look for the end offset of the largest list of ' ' loc_start = full_txt_start + max(matches, key=lambda x: len(x.group())).end() loc_end = loc_start + len(old_str) @@ -475,9 +475,9 @@ def _explore_functions(slither, functions, result, target, convert): # The name is after the space if isinstance(target, Modifier): - matches = re.finditer('modifier([ ]*)', full_txt) + matches = re.finditer(b'modifier([ ]*)', full_txt) else: - matches = re.finditer('function([ ]*)', full_txt) + matches = re.finditer(b'function([ ]*)', full_txt) # Look for the end offset of the largest list of ' ' loc_start = full_txt_start + max(matches, key=lambda x: len(x.group())).end() loc_end = loc_start + len(old_str) @@ -502,7 +502,7 @@ def _explore_enums(slither, enums, result, target, convert): full_txt = slither.source_code[filename_source_code].encode('utf8')[full_txt_start:full_txt_end] # The name is after the space - matches = re.finditer('enum([ ]*)', full_txt) + matches = re.finditer(b'enum([ ]*)', full_txt) # Look for the end offset of the largest list of ' ' loc_start = full_txt_start + max(matches, key=lambda x: len(x.group())).end() loc_end = loc_start + len(old_str) @@ -531,7 +531,7 @@ def _explore_contract(slither, contract, result, target, convert): new_str = convert(old_str, slither) # The name is after the space - matches = re.finditer('contract[ ]*', full_txt) + matches = re.finditer(b'contract[ ]*', full_txt) # Look for the end offset of the largest list of ' ' loc_start = full_txt_start + max(matches, key=lambda x: len(x.group())).end() From 63cde3bfe5bd080100876057dce60eee826d1d82 Mon Sep 17 00:00:00 2001 From: Josselin Date: Wed, 11 Sep 2019 09:26:03 +0200 Subject: [PATCH 153/223] Patch comment --- .../formatters/naming_convention.py | 44 ++++++++++++++++++- 1 file changed, 42 insertions(+), 2 deletions(-) diff --git a/slither/tools/slither_format/formatters/naming_convention.py b/slither/tools/slither_format/formatters/naming_convention.py index 4a40f58a3..05ec113e9 100644 --- a/slither/tools/slither_format/formatters/naming_convention.py +++ b/slither/tools/slither_format/formatters/naming_convention.py @@ -6,6 +6,7 @@ from slither.core.declarations import Modifier from slither.core.solidity_types import UserDefinedType, MappingType from slither.core.declarations import Enum, Contract, Structure from slither.core.solidity_types.elementary_type import ElementaryTypeName +from slither.core.variables.local_variable import LocalVariable from ..exceptions import FormatError, FormatImpossible from ..utils.patches import create_patch @@ -302,7 +303,7 @@ def _explore_type(slither, result, target, convert, type, filename_source_code, -def _explore_variables_declaration(slither, variables, result, target, convert): +def _explore_variables_declaration(slither, variables, result, target, convert, patch_comment=False): for variable in variables: # First explore the type of the variable filename_source_code = variable.source_mapping['filename_absolute'] @@ -340,6 +341,45 @@ def _explore_variables_declaration(slither, variables, result, target, convert): old_str, new_str) + # Patch comment only makes sense for local variable declaration in the parameter list + if patch_comment and isinstance(variable, LocalVariable): + if 'lines' in variable.source_mapping and variable.source_mapping['lines']: + end_line = variable.source_mapping['lines'][0] + func = variable.function + if variable in func.parameters: + idx = len(func.parameters) - func.parameters.index(variable) + first_line = end_line - idx - 2 + + potential_comments = slither.source_code[filename_source_code].encode('utf8') + potential_comments = potential_comments.splitlines(keepends=True)[first_line:end_line-1] + + idx_beginning = variable.source_mapping['start'] + idx_beginning += - variable.source_mapping['starting_column'] + 1 + idx_beginning += - sum([len(c) for c in potential_comments]) + + old_comment = f'@param {old_str}'.encode('utf8') + print(f'idx beging {idx_beginning}') + + for line in potential_comments: + idx = line.find(old_comment) + if idx >=0: + loc_start = idx + idx_beginning + print(loc_start) + loc_end = loc_start + len(old_comment) + new_comment = f'@param {new_str}'.encode('utf8') + + create_patch(result, + filename_source_code, + loc_start, + loc_end, + old_comment, + new_comment) + + break + idx_beginning += len(line) + + + def _explore_modifiers_calls(slither, function, result, target, convert): for modifier in function.modifiers_statements: @@ -460,7 +500,7 @@ def _explore_irs(slither, irs, result, target, convert): def _explore_functions(slither, functions, result, target, convert): for function in functions: - _explore_variables_declaration(slither, function.variables, result, target, convert) + _explore_variables_declaration(slither, function.variables, result, target, convert, True) _explore_modifiers_calls(slither, function, result, target, convert) _explore_irs(slither, function.all_slithir_operations(), result, target, convert) From 1ef8dbe69de4cc76580b214bdd482fa0d395b529 Mon Sep 17 00:00:00 2001 From: Josselin Date: Wed, 11 Sep 2019 18:23:53 +0200 Subject: [PATCH 154/223] Fix incorrect abi.decode translation --- slither/slithir/convert.py | 65 ++++++++++++------- slither/solc_parsing/declarations/function.py | 3 +- 2 files changed, 45 insertions(+), 23 deletions(-) diff --git a/slither/slithir/convert.py b/slither/slithir/convert.py index c50a4f8a6..af564602e 100644 --- a/slither/slithir/convert.py +++ b/slither/slithir/convert.py @@ -375,6 +375,10 @@ def propagate_types(ir, node): if t is None: return + if isinstance(t, ElementaryType) and t.name == 'address': + if can_be_solidity_func(ir): + return convert_to_solidity_func(ir) + # convert library if t in using_for or '*' in using_for: new_ir = convert_to_library(ir, node, using_for) @@ -392,7 +396,8 @@ def propagate_types(ir, node): if isinstance(t, ElementaryType) and t.name == 'address': if ir.destination.name == 'this': return convert_type_of_high_and_internal_level_call(ir, node.function.contract) - return convert_to_low_level(ir) + if can_be_low_level(ir): + return convert_to_low_level(ir) # Convert push operations # May need to insert a new operation @@ -605,13 +610,21 @@ def extract_tmp_call(ins, contract): ################################################################################### ################################################################################### +def can_be_low_level(ir): + return ir.function_name in ['transfer', + 'send', + 'call', + 'delegatecall', + 'callcode', + 'staticcall'] + def convert_to_low_level(ir): """ Convert to a transfer/send/or low level call The funciton assume to receive a correct IR The checks must be done by the caller - Additionally convert abi... to solidityfunction + Must be called after can_be_low_level """ if ir.function_name == 'transfer': assert len(ir.arguments) == 1 @@ -622,20 +635,6 @@ def convert_to_low_level(ir): ir = Send(ir.destination, ir.arguments[0], ir.lvalue) ir.lvalue.set_type(ElementaryType('bool')) return ir - elif ir.destination.name == 'abi' and ir.function_name in ['encode', - 'encodePacked', - 'encodeWithSelector', - 'encodeWithSignature', - 'decode']: - - call = SolidityFunction('abi.{}()'.format(ir.function_name)) - new_ir = SolidityCall(call, ir.nbr_arguments, ir.lvalue, ir.type_call) - new_ir.arguments = ir.arguments - if isinstance(call.return_type, list) and len(call.return_type) == 1: - new_ir.lvalue.set_type(call.return_type[0]) - else: - new_ir.lvalue.set_type(call.return_type) - return new_ir elif ir.function_name in ['call', 'delegatecall', 'callcode', @@ -652,6 +651,29 @@ def convert_to_low_level(ir): return new_ir raise SlithIRError('Incorrect conversion to low level {}'.format(ir)) + +def can_be_solidity_func(ir): + return ir.destination.name == 'abi' and ir.function_name in ['encode', + 'encodePacked', + 'encodeWithSelector', + 'encodeWithSignature', + 'decode'] + +def convert_to_solidity_func(ir): + """ + Must be called after can_be_solidity_func + :param ir: + :return: + """ + call = SolidityFunction('abi.{}()'.format(ir.function_name)) + new_ir = SolidityCall(call, ir.nbr_arguments, ir.lvalue, ir.type_call) + new_ir.arguments = ir.arguments + if isinstance(call.return_type, list) and len(call.return_type) == 1: + new_ir.lvalue.set_type(call.return_type[0]) + else: + new_ir.lvalue.set_type(call.return_type) + return new_ir + def convert_to_push(ir, node): """ Convert a call to a PUSH operaiton @@ -815,12 +837,11 @@ def convert_type_of_high_and_internal_level_call(ir, contract): func = function break # lowlelvel lookup needs to be done at last step - if not func and ir.function_name in ['call', - 'delegatecall', - 'callcode', - 'transfer', - 'send']: - return convert_to_low_level(ir) + if not func: + if can_be_low_level(ir): + return convert_to_low_level(ir) + if can_be_solidity_func(ir): + return convert_to_solidity_func(ir) if not func: logger.error('Function not found {}'.format(sig)) ir.function = func diff --git a/slither/solc_parsing/declarations/function.py b/slither/solc_parsing/declarations/function.py index 9ec13cef8..89f049918 100644 --- a/slither/solc_parsing/declarations/function.py +++ b/slither/solc_parsing/declarations/function.py @@ -499,7 +499,8 @@ class FunctionSolc(Function): variables = statement['declarations'] count = len(variables) - if statement['initialValue']['nodeType'] == 'TupleExpression': + if statement['initialValue']['nodeType'] == 'TupleExpression' and \ + len(statement['initialValue']['components']) == count: inits = statement['initialValue']['components'] i = 0 new_node = node From 07a7897a2289e86682d704e2d7b9a17e319f716a Mon Sep 17 00:00:00 2001 From: Josselin Date: Wed, 11 Sep 2019 09:52:39 +0200 Subject: [PATCH 155/223] Add IR conversion for constant state variable conversion --- slither/core/declarations/function.py | 7 ++++-- slither/solc_parsing/cfg/node.py | 10 +++++--- slither/solc_parsing/declarations/contract.py | 25 +++++++++++++++++++ .../expressions/expression_parsing.py | 4 ++- 4 files changed, 39 insertions(+), 7 deletions(-) diff --git a/slither/core/declarations/function.py b/slither/core/declarations/function.py index 71f22ddfc..998b4d970 100644 --- a/slither/core/declarations/function.py +++ b/slither/core/declarations/function.py @@ -55,6 +55,7 @@ class FunctionType(Enum): CONSTRUCTOR = 1 FALLBACK = 2 CONSTRUCTOR_VARIABLES = 3 # Fake function to hold variable declaration statements + CONSTRUCTOR_CONSTANT_VARIABLES = 4 # Fake function to hold variable declaration statements class Function(ChildContract, ChildInheritance, SourceMapping): """ @@ -153,6 +154,8 @@ class Function(ChildContract, ChildInheritance, SourceMapping): return 'fallback' elif self._function_type == FunctionType.CONSTRUCTOR_VARIABLES: return 'slitherConstructorVariables' + elif self._function_type == FunctionType.CONSTRUCTOR_CONSTANT_VARIABLES: + return 'slitherConstructorConstantVariables' return self._name @property @@ -245,9 +248,9 @@ class Function(ChildContract, ChildInheritance, SourceMapping): def is_constructor_variables(self): """ bool: True if the function is the constructor of the variables - Slither has a inbuilt function to hold the state variables initialization + Slither has inbuilt functions to hold the state variables initialization """ - return self._function_type == FunctionType.CONSTRUCTOR_VARIABLES + return self._function_type in [FunctionType.CONSTRUCTOR_VARIABLES, FunctionType.CONSTRUCTOR_CONSTANT_VARIABLES] @property def is_fallback(self): diff --git a/slither/solc_parsing/cfg/node.py b/slither/solc_parsing/cfg/node.py index 1775084f6..08be502e2 100644 --- a/slither/solc_parsing/cfg/node.py +++ b/slither/solc_parsing/cfg/node.py @@ -37,10 +37,12 @@ class NodeSolc(Node): if self.type == NodeType.VARIABLE: # Update the expression to be an assignement to the variable #print(self.variable_declaration) - self._expression = AssignmentOperation(Identifier(self.variable_declaration), - self.expression, - AssignmentOperationType.ASSIGN, - self.variable_declaration.type) + _expression = AssignmentOperation(Identifier(self.variable_declaration), + self.expression, + AssignmentOperationType.ASSIGN, + self.variable_declaration.type) + _expression.set_offset(self.expression.source_mapping, self.slither) + self._expression = _expression expression = self.expression pp = ReadVar(expression) diff --git a/slither/solc_parsing/declarations/contract.py b/slither/solc_parsing/declarations/contract.py index d36e9150a..ebb43a185 100644 --- a/slither/solc_parsing/declarations/contract.py +++ b/slither/solc_parsing/declarations/contract.py @@ -382,6 +382,7 @@ class ContractSolc04(Contract): AssignmentOperationType.ASSIGN, variable.type) + expression.set_offset(variable.source_mapping, self.slither) node.add_expression(expression) return node @@ -408,12 +409,36 @@ class ContractSolc04(Contract): prev_node.add_son(next_node) next_node.add_father(prev_node) counter += 1 + break + + for (idx, variable_candidate) in enumerate(self.state_variables): + if variable_candidate.expression and variable_candidate.is_constant: + + constructor_variable = Function() + constructor_variable.set_function_type(FunctionType.CONSTRUCTOR_CONSTANT_VARIABLES) + constructor_variable.set_contract(self) + constructor_variable.set_contract_declarer(self) + constructor_variable.set_visibility('internal') + # For now, source mapping of the constructor variable is the whole contract + # Could be improved with a targeted source mapping + constructor_variable.set_offset(self.source_mapping, self.slither) + self._functions[constructor_variable.canonical_name] = constructor_variable + + prev_node = self._create_node(constructor_variable, 0, variable_candidate) + counter = 1 + for v in self.state_variables[idx+1:]: + if v.expression and v.is_constant: + next_node = self._create_node(constructor_variable, counter, v) + prev_node.add_son(next_node) + next_node.add_father(prev_node) + counter += 1 break + def analyze_state_variables(self): for var in self.variables: var.analyze(self) diff --git a/slither/solc_parsing/expressions/expression_parsing.py b/slither/solc_parsing/expressions/expression_parsing.py index e76deb8fd..4580e7361 100644 --- a/slither/solc_parsing/expressions/expression_parsing.py +++ b/slither/solc_parsing/expressions/expression_parsing.py @@ -569,7 +569,9 @@ def parse_expression(expression, caller_context): var = find_variable(super_name, caller_context, is_super=True) if var is None: raise VariableNotFound('Variable not found: {}'.format(super_name)) - return SuperIdentifier(var) + sup = SuperIdentifier(var) + sup.set_offset(expression['src'], caller_context.slither) + return sup member_access = MemberAccess(member_name, member_type, member_expression) if str(member_access) in SOLIDITY_VARIABLES_COMPOSED: return Identifier(SolidityVariableComposed(str(member_access))) From 122b4268cf0525cdcac1ac8a4adfea7bbb18025f Mon Sep 17 00:00:00 2001 From: Josselin Date: Wed, 11 Sep 2019 09:34:37 +0200 Subject: [PATCH 156/223] Fix incorrect variable idx --- slither/core/declarations/function.py | 7 ++++-- slither/solc_parsing/declarations/contract.py | 24 +++++++++++++++++++ .../formatters/naming_convention.py | 9 +------ 3 files changed, 30 insertions(+), 10 deletions(-) diff --git a/slither/core/declarations/function.py b/slither/core/declarations/function.py index 71f22ddfc..998b4d970 100644 --- a/slither/core/declarations/function.py +++ b/slither/core/declarations/function.py @@ -55,6 +55,7 @@ class FunctionType(Enum): CONSTRUCTOR = 1 FALLBACK = 2 CONSTRUCTOR_VARIABLES = 3 # Fake function to hold variable declaration statements + CONSTRUCTOR_CONSTANT_VARIABLES = 4 # Fake function to hold variable declaration statements class Function(ChildContract, ChildInheritance, SourceMapping): """ @@ -153,6 +154,8 @@ class Function(ChildContract, ChildInheritance, SourceMapping): return 'fallback' elif self._function_type == FunctionType.CONSTRUCTOR_VARIABLES: return 'slitherConstructorVariables' + elif self._function_type == FunctionType.CONSTRUCTOR_CONSTANT_VARIABLES: + return 'slitherConstructorConstantVariables' return self._name @property @@ -245,9 +248,9 @@ class Function(ChildContract, ChildInheritance, SourceMapping): def is_constructor_variables(self): """ bool: True if the function is the constructor of the variables - Slither has a inbuilt function to hold the state variables initialization + Slither has inbuilt functions to hold the state variables initialization """ - return self._function_type == FunctionType.CONSTRUCTOR_VARIABLES + return self._function_type in [FunctionType.CONSTRUCTOR_VARIABLES, FunctionType.CONSTRUCTOR_CONSTANT_VARIABLES] @property def is_fallback(self): diff --git a/slither/solc_parsing/declarations/contract.py b/slither/solc_parsing/declarations/contract.py index d36e9150a..3f8b52f6f 100644 --- a/slither/solc_parsing/declarations/contract.py +++ b/slither/solc_parsing/declarations/contract.py @@ -408,12 +408,36 @@ class ContractSolc04(Contract): prev_node.add_son(next_node) next_node.add_father(prev_node) counter += 1 + break + + for (idx, variable_candidate) in enumerate(self.state_variables): + if variable_candidate.expression and variable_candidate.is_constant: + + constructor_variable = Function() + constructor_variable.set_function_type(FunctionType.CONSTRUCTOR_CONSTANT_VARIABLES) + constructor_variable.set_contract(self) + constructor_variable.set_contract_declarer(self) + constructor_variable.set_visibility('internal') + # For now, source mapping of the constructor variable is the whole contract + # Could be improved with a targeted source mapping + constructor_variable.set_offset(self.source_mapping, self.slither) + self._functions[constructor_variable.canonical_name] = constructor_variable + + prev_node = self._create_node(constructor_variable, 0, variable_candidate) + counter = 1 + for v in self.state_variables[idx+1:]: + if v.expression and v.is_constant: + next_node = self._create_node(constructor_variable, counter, v) + prev_node.add_son(next_node) + next_node.add_father(prev_node) + counter += 1 break + def analyze_state_variables(self): for var in self.variables: var.analyze(self) diff --git a/slither/tools/slither_format/formatters/naming_convention.py b/slither/tools/slither_format/formatters/naming_convention.py index 05ec113e9..c130c2006 100644 --- a/slither/tools/slither_format/formatters/naming_convention.py +++ b/slither/tools/slither_format/formatters/naming_convention.py @@ -325,13 +325,7 @@ def _explore_variables_declaration(slither, variables, result, target, convert, old_str = variable.name new_str = convert(old_str, slither) - # The name is after the space - # We take all the space, as we dont know the type - # In comparison to other matches, it is ok as there will not be more than one - # 'spaces' zone (ex: for function, the body and the signature will also contain space) - matches = re.finditer(b'[ ]*', full_txt) - # Look for the end offset of the largest list of ' ' - loc_start = full_txt_start + max(matches, key=lambda x:len(x.group())).end() + loc_start = full_txt_start + full_txt.find(old_str.encode('utf8')) loc_end = loc_start + len(old_str) create_patch(result, @@ -532,7 +526,6 @@ def _explore_functions(slither, functions, result, target, convert): def _explore_enums(slither, enums, result, target, convert): for enum in enums: if enum == target: - print(target) old_str = enum.name new_str = convert(old_str, slither) From 9ad04d91281ab9eabca7058411ac51a350ea8cdc Mon Sep 17 00:00:00 2001 From: Josselin Date: Wed, 11 Sep 2019 10:17:26 +0200 Subject: [PATCH 157/223] Add missing source mapping --- slither/solc_parsing/cfg/node.py | 10 ++++++---- slither/solc_parsing/declarations/contract.py | 1 + slither/solc_parsing/expressions/expression_parsing.py | 4 +++- 3 files changed, 10 insertions(+), 5 deletions(-) diff --git a/slither/solc_parsing/cfg/node.py b/slither/solc_parsing/cfg/node.py index 1775084f6..c711b31c3 100644 --- a/slither/solc_parsing/cfg/node.py +++ b/slither/solc_parsing/cfg/node.py @@ -37,10 +37,12 @@ class NodeSolc(Node): if self.type == NodeType.VARIABLE: # Update the expression to be an assignement to the variable #print(self.variable_declaration) - self._expression = AssignmentOperation(Identifier(self.variable_declaration), - self.expression, - AssignmentOperationType.ASSIGN, - self.variable_declaration.type) + _expression = AssignmentOperation(Identifier(self.variable_declaration), + self.expression, + AssignmentOperationType.ASSIGN, + self.variable_declaration.type) + _expression.set_offset(self.expression.source_mapping, caller_context) + self._expression = _expression expression = self.expression pp = ReadVar(expression) diff --git a/slither/solc_parsing/declarations/contract.py b/slither/solc_parsing/declarations/contract.py index 3f8b52f6f..ebb43a185 100644 --- a/slither/solc_parsing/declarations/contract.py +++ b/slither/solc_parsing/declarations/contract.py @@ -382,6 +382,7 @@ class ContractSolc04(Contract): AssignmentOperationType.ASSIGN, variable.type) + expression.set_offset(variable.source_mapping, self.slither) node.add_expression(expression) return node diff --git a/slither/solc_parsing/expressions/expression_parsing.py b/slither/solc_parsing/expressions/expression_parsing.py index 92314a80a..4ccaeb275 100644 --- a/slither/solc_parsing/expressions/expression_parsing.py +++ b/slither/solc_parsing/expressions/expression_parsing.py @@ -581,7 +581,9 @@ def parse_expression(expression, caller_context): var = find_variable(super_name, caller_context, is_super=True) if var is None: raise VariableNotFound('Variable not found: {}'.format(super_name)) - return SuperIdentifier(var) + sup = SuperIdentifier(var) + sup.set_offset(expression['src'], caller_context) + return sup member_access = MemberAccess(member_name, member_type, member_expression) member_access.set_offset(expression['src'], caller_context.slither) if str(member_access) in SOLIDITY_VARIABLES_COMPOSED: From b600cae512474fb47406bdb471a94b2cebb8a955 Mon Sep 17 00:00:00 2001 From: Josselin Date: Wed, 11 Sep 2019 10:47:46 +0200 Subject: [PATCH 158/223] Improve comment patching + state variable constant patching --- .../tools/slither_format/formatters/constable_states.py | 4 +++- .../tools/slither_format/formatters/naming_convention.py | 8 ++++---- 2 files changed, 7 insertions(+), 5 deletions(-) diff --git a/slither/tools/slither_format/formatters/constable_states.py b/slither/tools/slither_format/formatters/constable_states.py index 67f51536f..373b0c405 100644 --- a/slither/tools/slither_format/formatters/constable_states.py +++ b/slither/tools/slither_format/formatters/constable_states.py @@ -1,10 +1,12 @@ import re -from ..exceptions import FormatError +from ..exceptions import FormatError, FormatImpossible from ..utils.patches import create_patch def format(slither, result): elements = result['elements'] for element in elements: + if not element.expression: + raise FormatImpossible(f'{element.name} is uninitialized and cannot become constant.') _patch(slither, result, element['source_mapping']['filename_absolute'], element['name'], "constant " + element['name'], diff --git a/slither/tools/slither_format/formatters/naming_convention.py b/slither/tools/slither_format/formatters/naming_convention.py index c130c2006..be2abcc86 100644 --- a/slither/tools/slither_format/formatters/naming_convention.py +++ b/slither/tools/slither_format/formatters/naming_convention.py @@ -338,17 +338,17 @@ def _explore_variables_declaration(slither, variables, result, target, convert, # Patch comment only makes sense for local variable declaration in the parameter list if patch_comment and isinstance(variable, LocalVariable): if 'lines' in variable.source_mapping and variable.source_mapping['lines']: - end_line = variable.source_mapping['lines'][0] func = variable.function + end_line = func.source_mapping['lines'][0] if variable in func.parameters: - idx = len(func.parameters) - func.parameters.index(variable) + idx = len(func.parameters) - func.parameters.index(variable) + 1 first_line = end_line - idx - 2 potential_comments = slither.source_code[filename_source_code].encode('utf8') potential_comments = potential_comments.splitlines(keepends=True)[first_line:end_line-1] - idx_beginning = variable.source_mapping['start'] - idx_beginning += - variable.source_mapping['starting_column'] + 1 + idx_beginning = func.source_mapping['start'] + idx_beginning += - func.source_mapping['starting_column'] + 1 idx_beginning += - sum([len(c) for c in potential_comments]) old_comment = f'@param {old_str}'.encode('utf8') From 78a8887acfe0ca3d9ad6a704aef56f98310df13a Mon Sep 17 00:00:00 2001 From: Josselin Date: Wed, 11 Sep 2019 10:57:37 +0200 Subject: [PATCH 159/223] Improve constant state filter --- .../slither_format/formatters/constable_states.py | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/slither/tools/slither_format/formatters/constable_states.py b/slither/tools/slither_format/formatters/constable_states.py index 373b0c405..d731e7aa5 100644 --- a/slither/tools/slither_format/formatters/constable_states.py +++ b/slither/tools/slither_format/formatters/constable_states.py @@ -5,8 +5,14 @@ from ..utils.patches import create_patch def format(slither, result): elements = result['elements'] for element in elements: - if not element.expression: - raise FormatImpossible(f'{element.name} is uninitialized and cannot become constant.') + + # TODO: decide if this should be changed in the constant detector + contract_name = element['type_specific_fields']['parent']['name'] + contract = slither.get_contract_from_name(contract_name) + var = contract.get_state_variable_from_name(element['name']) + if not var.expression: + raise FormatImpossible(f'{var.name} is uninitialized and cannot become constant.') + _patch(slither, result, element['source_mapping']['filename_absolute'], element['name'], "constant " + element['name'], From 7d42faad1e06fa3b5e6c762a9a6c6f2488a071dd Mon Sep 17 00:00:00 2001 From: Josselin Date: Wed, 11 Sep 2019 11:11:01 +0200 Subject: [PATCH 160/223] Fix constant function patch --- .../slither_format/formatters/constant_function.py | 13 +++++++------ slither/tools/slither_format/slither_format.py | 5 +++-- 2 files changed, 10 insertions(+), 8 deletions(-) diff --git a/slither/tools/slither_format/formatters/constant_function.py b/slither/tools/slither_format/formatters/constant_function.py index 02b09fa6a..7b3d5de84 100644 --- a/slither/tools/slither_format/formatters/constant_function.py +++ b/slither/tools/slither_format/formatters/constant_function.py @@ -2,7 +2,8 @@ import re from ..exceptions import FormatError from ..utils.patches import create_patch -def format(slither, patches, elements): +def format(slither, result): + elements = result['elements'] for element in elements: if element['type'] != "function": # Skip variable elements @@ -11,21 +12,21 @@ def format(slither, patches, elements): if target_contract: for function in target_contract.functions: if function.name == element['name']: - _patch(slither, patches, + _patch(slither, result, element['source_mapping']['filename_absolute'], - element['source_mapping']['filename_relative'], - int(function.parameters_src.source_mapping['start']), + int(function.parameters_src.source_mapping['start'] + + function.parameters_src.source_mapping['length']), int(function.returns_src.source_mapping['start'])) break -def _patch(slither, patches, in_file, in_file_relative, modify_loc_start, modify_loc_end): +def _patch(slither, result, in_file, modify_loc_start, modify_loc_end): in_file_str = slither.source_code[in_file].encode('utf8') old_str_of_interest = in_file_str[modify_loc_start:modify_loc_end] # Find the keywords view|pure|constant and remove them m = re.search("(view|pure|constant)", old_str_of_interest.decode('utf-8')) if m: - create_patch(patches, + create_patch(result, in_file, modify_loc_start + m.span()[0], modify_loc_start + m.span()[1], diff --git a/slither/tools/slither_format/slither_format.py b/slither/tools/slither_format/slither_format.py index 01cf1ee19..6420e76ee 100644 --- a/slither/tools/slither_format/slither_format.py +++ b/slither/tools/slither_format/slither_format.py @@ -7,7 +7,8 @@ from slither.detectors.naming_convention.naming_convention import NamingConventi 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 import unused_state, constable_states, pragma, solc_version, external_function, naming_convention +from .formatters import unused_state, constable_states, pragma, solc_version, \ + external_function, naming_convention, constant_function from .utils.patches import apply_patch, create_diff from .exceptions import FormatError, FormatImpossible @@ -127,7 +128,7 @@ def apply_detector_results(slither, detector_results): elif result['check'] == 'constable-states': constable_states.format(slither, result) elif result['check'] == 'constant-function': - constable_states.format(slither, result) + constant_function.format(slither, result) else: raise FormatError(result['check'] + "detector not supported yet.") except FormatImpossible as e: From 99e7b81afebd57b8ef591b8f816091e7485a0cc5 Mon Sep 17 00:00:00 2001 From: Josselin Date: Wed, 11 Sep 2019 11:19:29 +0200 Subject: [PATCH 161/223] Fix incorrect context given to set_offset --- slither/solc_parsing/cfg/node.py | 2 +- slither/solc_parsing/expressions/expression_parsing.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/slither/solc_parsing/cfg/node.py b/slither/solc_parsing/cfg/node.py index c711b31c3..08be502e2 100644 --- a/slither/solc_parsing/cfg/node.py +++ b/slither/solc_parsing/cfg/node.py @@ -41,7 +41,7 @@ class NodeSolc(Node): self.expression, AssignmentOperationType.ASSIGN, self.variable_declaration.type) - _expression.set_offset(self.expression.source_mapping, caller_context) + _expression.set_offset(self.expression.source_mapping, self.slither) self._expression = _expression expression = self.expression diff --git a/slither/solc_parsing/expressions/expression_parsing.py b/slither/solc_parsing/expressions/expression_parsing.py index 4ccaeb275..fd199d882 100644 --- a/slither/solc_parsing/expressions/expression_parsing.py +++ b/slither/solc_parsing/expressions/expression_parsing.py @@ -582,7 +582,7 @@ def parse_expression(expression, caller_context): if var is None: raise VariableNotFound('Variable not found: {}'.format(super_name)) sup = SuperIdentifier(var) - sup.set_offset(expression['src'], caller_context) + sup.set_offset(expression['src'], caller_context.slither) return sup member_access = MemberAccess(member_name, member_type, member_expression) member_access.set_offset(expression['src'], caller_context.slither) From 2832d62ba430369d387bb599892acd8b822b0ef0 Mon Sep 17 00:00:00 2001 From: Josselin Date: Thu, 12 Sep 2019 09:24:59 +0200 Subject: [PATCH 162/223] Improve external function detector: merge together shadowed function --- .../detectors/functions/external_function.py | 24 +++++++++++++------ .../external_function.external-function.json | 10 ++++---- .../external_function.external-function.txt | 19 +++++++++------ .../external_function_2.external-function.txt | 2 +- 4 files changed, 35 insertions(+), 20 deletions(-) diff --git a/slither/detectors/functions/external_function.py b/slither/detectors/functions/external_function.py index e2250ba3a..732488780 100644 --- a/slither/detectors/functions/external_function.py +++ b/slither/detectors/functions/external_function.py @@ -172,14 +172,24 @@ class ExternalFunction(AbstractDetector): if is_called: continue - # Loop for each function definition, and recommend it be declared external. - for function_definition in all_function_definitions: - txt = "{} ({}) should be declared external\n" - info = txt.format(function_definition.canonical_name, - function_definition.source_mapping_str) - - json = self.generate_json_result(info) + # As we collect all shadowed functions in get_all_function_definitions + # Some function coming from a base might already been declared as external + all_function_definitions = [f for f in all_function_definitions if f.visibility == 'public' and + f.contract == f.contract_declarer] + if all_function_definitions: + function_definition = all_function_definitions[0] + all_function_definitions = all_function_definitions[1:] + + txt = f"{function_definition.full_name} should be declared external:\n" + txt += f"\t- {function_definition.canonical_name} ({function_definition.source_mapping_str})\n" + for other_function_definition in all_function_definitions: + txt += f"\t- {other_function_definition.canonical_name}" + txt += f" ({other_function_definition.source_mapping_str})\n" + + json = self.generate_json_result(txt) self.add_function_to_json(function_definition, json) + for other_function_definition in all_function_definitions: + self.add_function_to_json(other_function_definition, json) results.append(json) return results diff --git a/tests/expected_json/external_function.external-function.json b/tests/expected_json/external_function.external-function.json index d60c5ef49..026c45140 100644 --- a/tests/expected_json/external_function.external-function.json +++ b/tests/expected_json/external_function.external-function.json @@ -7,7 +7,7 @@ "check": "external-function", "impact": "Optimization", "confidence": "High", - "description": "ContractWithFunctionNotCalled.funcNotCalled3() (tests/external_function.sol#13-15) should be declared external\n", + "description": "funcNotCalled3() should be declared external:\n\t- ContractWithFunctionNotCalled.funcNotCalled3() (tests/external_function.sol#13-15)\n", "elements": [ { "type": "function", @@ -74,7 +74,7 @@ "check": "external-function", "impact": "Optimization", "confidence": "High", - "description": "ContractWithFunctionNotCalled.funcNotCalled2() (tests/external_function.sol#17-19) should be declared external\n", + "description": "funcNotCalled2() should be declared external:\n\t- ContractWithFunctionNotCalled.funcNotCalled2() (tests/external_function.sol#17-19)\n", "elements": [ { "type": "function", @@ -141,7 +141,7 @@ "check": "external-function", "impact": "Optimization", "confidence": "High", - "description": "ContractWithFunctionNotCalled.funcNotCalled() (tests/external_function.sol#21-23) should be declared external\n", + "description": "funcNotCalled() should be declared external:\n\t- ContractWithFunctionNotCalled.funcNotCalled() (tests/external_function.sol#21-23)\n", "elements": [ { "type": "function", @@ -208,7 +208,7 @@ "check": "external-function", "impact": "Optimization", "confidence": "High", - "description": "ContractWithFunctionNotCalled2.funcNotCalled() (tests/external_function.sol#32-39) should be declared external\n", + "description": "funcNotCalled() should be declared external:\n\t- ContractWithFunctionNotCalled2.funcNotCalled() (tests/external_function.sol#32-39)\n", "elements": [ { "type": "function", @@ -271,7 +271,7 @@ "check": "external-function", "impact": "Optimization", "confidence": "High", - "description": "FunctionParameterWrite.parameter_read_ok_for_external(uint256) (tests/external_function.sol#74-76) should be declared external\n", + "description": "parameter_read_ok_for_external(uint256) should be declared external:\n\t- FunctionParameterWrite.parameter_read_ok_for_external(uint256) (tests/external_function.sol#74-76)\n", "elements": [ { "type": "function", diff --git a/tests/expected_json/external_function.external-function.txt b/tests/expected_json/external_function.external-function.txt index 82470ba0d..a0f3d6499 100644 --- a/tests/expected_json/external_function.external-function.txt +++ b/tests/expected_json/external_function.external-function.txt @@ -1,8 +1,13 @@ -INFO:Detectors: -ContractWithFunctionNotCalled.funcNotCalled3() (tests/external_function.sol#13-15) should be declared external -ContractWithFunctionNotCalled.funcNotCalled2() (tests/external_function.sol#17-19) should be declared external -ContractWithFunctionNotCalled.funcNotCalled() (tests/external_function.sol#21-23) should be declared external -ContractWithFunctionNotCalled2.funcNotCalled() (tests/external_function.sol#32-39) should be declared external -FunctionParameterWrite.parameter_read_ok_for_external(uint256) (tests/external_function.sol#74-76) should be declared external + +funcNotCalled3() should be declared external: + - ContractWithFunctionNotCalled.funcNotCalled3() (tests/external_function.sol#13-15) +funcNotCalled2() should be declared external: + - ContractWithFunctionNotCalled.funcNotCalled2() (tests/external_function.sol#17-19) +funcNotCalled() should be declared external: + - ContractWithFunctionNotCalled.funcNotCalled() (tests/external_function.sol#21-23) +funcNotCalled() should be declared external: + - ContractWithFunctionNotCalled2.funcNotCalled() (tests/external_function.sol#32-39) +parameter_read_ok_for_external(uint256) should be declared external: + - FunctionParameterWrite.parameter_read_ok_for_external(uint256) (tests/external_function.sol#74-76) Reference: https://github.com/crytic/slither/wiki/Detector-Documentation#public-function-that-could-be-declared-as-external -INFO:Slither:tests/external_function.sol analyzed (6 contracts), 5 result(s) found +tests/external_function.sol analyzed (6 contracts with 1 detectors), 5 result(s) found diff --git a/tests/expected_json/external_function_2.external-function.txt b/tests/expected_json/external_function_2.external-function.txt index 352324d7f..a61fb7600 100644 --- a/tests/expected_json/external_function_2.external-function.txt +++ b/tests/expected_json/external_function_2.external-function.txt @@ -1 +1 @@ -INFO:Slither:tests/external_function_2.sol analyzed (4 contracts), 0 result(s) found +tests/external_function_2.sol analyzed (4 contracts with 1 detectors), 0 result(s) found From 37908309a80f9830bd4aedf0ff26d00d838774f4 Mon Sep 17 00:00:00 2001 From: Josselin Date: Thu, 12 Sep 2019 09:40:08 +0200 Subject: [PATCH 163/223] Add source mapping to inner expressions --- .../expressions/expression_parsing.py | 31 ++++++++++++++----- 1 file changed, 24 insertions(+), 7 deletions(-) diff --git a/slither/solc_parsing/expressions/expression_parsing.py b/slither/solc_parsing/expressions/expression_parsing.py index 4580e7361..f256611f6 100644 --- a/slither/solc_parsing/expressions/expression_parsing.py +++ b/slither/solc_parsing/expressions/expression_parsing.py @@ -228,7 +228,7 @@ def filter_name(value): ################################################################################### def parse_call(expression, caller_context): - + src = expression['src'] if caller_context.is_compact_ast: attributes = expression type_conversion = expression['kind'] == 'typeConversion' @@ -261,6 +261,7 @@ def parse_call(expression, caller_context): expression = parse_expression(expression_to_parse, caller_context) t = TypeConversion(expression, type_call) + t.set_offset(src, caller_context.slither) return t if caller_context.is_compact_ast: @@ -276,7 +277,7 @@ def parse_call(expression, caller_context): if isinstance(called, SuperCallExpression): return SuperCallExpression(called, arguments, type_return) call_expression = CallExpression(called, arguments, type_return) - call_expression.set_offset(expression['src'], caller_context.slither) + call_expression.set_offset(src, caller_context.slither) return call_expression def parse_super_name(expression, is_compact_ast): @@ -311,7 +312,9 @@ def _parse_elementary_type_name_expression(expression, is_compact_ast, caller_co value = expression['attributes']['value'] t = parse_type(UnknownType(value), caller_context) - return ElementaryTypeNameExpression(t) + e = ElementaryTypeNameExpression(t) + e.set_offset(expression['src'], caller_context.slither) + return e def parse_expression(expression, caller_context): """ @@ -345,6 +348,7 @@ def parse_expression(expression, caller_context): # The AST naming does not follow the spec name = expression[caller_context.get_key()] is_compact_ast = caller_context.is_compact_ast + src = expression['src'] if name == 'UnaryOperation': if is_compact_ast: @@ -360,6 +364,7 @@ def parse_expression(expression, caller_context): assert len(expression['children']) == 1 expression = parse_expression(expression['children'][0], caller_context) unary_op = UnaryOperation(expression, operation_type) + unary_op.set_offset(src, caller_context.slither) return unary_op elif name == 'BinaryOperation': @@ -377,6 +382,7 @@ def parse_expression(expression, caller_context): left_expression = parse_expression(expression['children'][0], caller_context) right_expression = parse_expression(expression['children'][1], caller_context) binary_op = BinaryOperation(left_expression, right_expression, operation_type) + binary_op.set_offset(src, caller_context.slither) return binary_op elif name == 'FunctionCall': @@ -414,6 +420,7 @@ def parse_expression(expression, caller_context): if elems[idx] == '': expressions.insert(idx, None) t = TupleExpression(expressions) + t.set_offset(src, caller_context.slither) return t elif name == 'Conditional': @@ -428,6 +435,7 @@ def parse_expression(expression, caller_context): then_expression = parse_expression(children[1], caller_context) else_expression = parse_expression(children[2], caller_context) conditional = ConditionalExpression(if_expression, then_expression, else_expression) + conditional.set_offset(src, caller_context.slither) return conditional elif name == 'Assignment': @@ -449,6 +457,7 @@ def parse_expression(expression, caller_context): operation_return_type = attributes['type'] assignement = AssignmentOperation(left_expression, right_expression, operation_type, operation_return_type) + assignement.set_offset(src, caller_context.slither) return assignement @@ -498,6 +507,7 @@ def parse_expression(expression, caller_context): else: type = ElementaryType('string') literal = Literal(value, type, subdenomination) + literal.set_offset(src, caller_context.slither) return literal elif name == 'Identifier': @@ -528,7 +538,7 @@ def parse_expression(expression, caller_context): var = find_variable(value, caller_context, referenced_declaration) identifier = Identifier(var) - identifier.set_offset(expression['src'], caller_context.slither) + identifier.set_offset(src, caller_context.slither) return identifier elif name == 'IndexAccess': @@ -551,6 +561,7 @@ def parse_expression(expression, caller_context): left_expression = parse_expression(left, caller_context) right_expression = parse_expression(right, caller_context) index = IndexAccess(left_expression, right_expression, index_type) + index.set_offset(src, caller_context.slither) return index elif name == 'MemberAccess': @@ -570,11 +581,14 @@ def parse_expression(expression, caller_context): if var is None: raise VariableNotFound('Variable not found: {}'.format(super_name)) sup = SuperIdentifier(var) - sup.set_offset(expression['src'], caller_context.slither) + sup.set_offset(src, caller_context.slither) return sup member_access = MemberAccess(member_name, member_type, member_expression) + member_access.set_offset(src, caller_context.slither) if str(member_access) in SOLIDITY_VARIABLES_COMPOSED: - return Identifier(SolidityVariableComposed(str(member_access))) + idx = Identifier(SolidityVariableComposed(str(member_access))) + idx.set_offset(src, caller_context.slither) + return idx return member_access elif name == 'ElementaryTypeNameExpression': @@ -616,6 +630,7 @@ def parse_expression(expression, caller_context): else: raise ParsingError('Incorrect type array {}'.format(type_name)) array = NewArray(depth, array_type) + array.set_offset(src, caller_context.slither) return array if type_name[caller_context.get_key()] == 'ElementaryTypeName': @@ -624,6 +639,7 @@ def parse_expression(expression, caller_context): else: elem_type = ElementaryType(type_name['attributes']['name']) new_elem = NewElementaryType(elem_type) + new_elem.set_offset(src, caller_context.slither) return new_elem assert type_name[caller_context.get_key()] == 'UserDefinedTypeName' @@ -633,6 +649,7 @@ def parse_expression(expression, caller_context): else: contract_name = type_name['attributes']['name'] new = NewContract(contract_name) + new.set_offset(src, caller_context.slither) return new elif name == 'ModifierInvocation': @@ -648,7 +665,7 @@ def parse_expression(expression, caller_context): arguments = [parse_expression(a, caller_context) for a in children[1::]] call = CallExpression(called, arguments, 'Modifier') - call.set_offset(expression['src'], caller_context.slither) + call.set_offset(src, caller_context.slither) return call raise ParsingError('Expression not parsed %s'%name) From 9d7870ac836fd58123f576f0f74d1af211d9e525 Mon Sep 17 00:00:00 2001 From: Josselin Date: Thu, 12 Sep 2019 09:52:00 +0200 Subject: [PATCH 164/223] Minor --- slither/solc_parsing/expressions/expression_parsing.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/slither/solc_parsing/expressions/expression_parsing.py b/slither/solc_parsing/expressions/expression_parsing.py index db5d557ca..dc565c574 100644 --- a/slither/solc_parsing/expressions/expression_parsing.py +++ b/slither/solc_parsing/expressions/expression_parsing.py @@ -361,7 +361,7 @@ def parse_expression(expression, caller_context): operation_type = UnaryOperationType.get_type(attributes['operator'], attributes['prefix']) if is_compact_ast: - expression_parsed = parse_expression(expression['subExpression'], caller_context) + expression = parse_expression(expression['subExpression'], caller_context) else: assert len(expression['children']) == 1 expression = parse_expression(expression['children'][0], caller_context) From c679a2a4e4c9cfdbe51295019f42781c0684e8d5 Mon Sep 17 00:00:00 2001 From: Josselin Date: Thu, 12 Sep 2019 10:18:19 +0200 Subject: [PATCH 165/223] Use signture to get function + improve naming convention to use canonical name comparison --- .../formatters/constant_function.py | 16 ++++++++-------- .../formatters/external_function.py | 14 +++++++------- .../formatters/naming_convention.py | 8 +++++--- 3 files changed, 20 insertions(+), 18 deletions(-) diff --git a/slither/tools/slither_format/formatters/constant_function.py b/slither/tools/slither_format/formatters/constant_function.py index 7b3d5de84..ee8b4fc2e 100644 --- a/slither/tools/slither_format/formatters/constant_function.py +++ b/slither/tools/slither_format/formatters/constant_function.py @@ -10,14 +10,14 @@ def format(slither, result): continue target_contract = slither.get_contract_from_name(element['type_specific_fields']['parent']['name']) if target_contract: - for function in target_contract.functions: - if function.name == element['name']: - _patch(slither, result, - element['source_mapping']['filename_absolute'], - int(function.parameters_src.source_mapping['start'] + - function.parameters_src.source_mapping['length']), - int(function.returns_src.source_mapping['start'])) - break + function = target_contract.get_function_from_signature(element['type_specific_fields']['signature']) + if function: + _patch(slither, + result, + element['source_mapping']['filename_absolute'], + int(function.parameters_src.source_mapping['start'] + + function.parameters_src.source_mapping['length']), + int(function.returns_src.source_mapping['start'])) def _patch(slither, result, in_file, modify_loc_start, modify_loc_end): diff --git a/slither/tools/slither_format/formatters/external_function.py b/slither/tools/slither_format/formatters/external_function.py index b3f999a41..ffdff7eb4 100644 --- a/slither/tools/slither_format/formatters/external_function.py +++ b/slither/tools/slither_format/formatters/external_function.py @@ -6,13 +6,13 @@ def format(slither, result): for element in elements: target_contract = slither.get_contract_from_name(element['type_specific_fields']['parent']['name']) if target_contract: - for function in target_contract.functions: - if function.name == element['name']: - _patch(slither, result, - element['source_mapping']['filename_absolute'], - int(function.parameters_src.source_mapping['start']), - int(function.returns_src.source_mapping['start'])) - break + function = target_contract.get_function_from_signature(element['type_specific_fields']['signature']) + if function: + _patch(slither, + result, + element['source_mapping']['filename_absolute'], + int(function.parameters_src.source_mapping['start']), + int(function.returns_src.source_mapping['start'])) def _patch(slither, result, in_file, modify_loc_start, modify_loc_end): diff --git a/slither/tools/slither_format/formatters/naming_convention.py b/slither/tools/slither_format/formatters/naming_convention.py index be2abcc86..d9199daf4 100644 --- a/slither/tools/slither_format/formatters/naming_convention.py +++ b/slither/tools/slither_format/formatters/naming_convention.py @@ -4,7 +4,7 @@ from slither.slithir.operations import Send, Transfer, OperationWithLValue, High InternalCall, InternalDynamicCall from slither.core.declarations import Modifier from slither.core.solidity_types import UserDefinedType, MappingType -from slither.core.declarations import Enum, Contract, Structure +from slither.core.declarations import Enum, Contract, Structure, Function from slither.core.solidity_types.elementary_type import ElementaryTypeName from slither.core.variables.local_variable import LocalVariable from ..exceptions import FormatError, FormatImpossible @@ -458,7 +458,9 @@ def _explore_irs(slither, irs, result, target, convert): return for ir in irs: for v in get_ir_variables(ir): - if target == v: + if target == v or ( + isinstance(target, Function) and isinstance(v, Function) and + v.canonical_name == target.canonical_name): source_mapping = ir.expression.source_mapping filename_source_code = source_mapping['filename_absolute'] full_txt_start = source_mapping['start'] @@ -498,7 +500,7 @@ def _explore_functions(slither, functions, result, target, convert): _explore_modifiers_calls(slither, function, result, target, convert) _explore_irs(slither, function.all_slithir_operations(), result, target, convert) - if function == target: + if function.canonical_name == target.canonical_name: old_str = function.name new_str = convert(old_str, slither) From a1b4c31d91c93b91ef5d558bc226fd237779bc3a Mon Sep 17 00:00:00 2001 From: Josselin Date: Thu, 12 Sep 2019 11:13:53 +0200 Subject: [PATCH 166/223] Create one directory per result (might contain multiple patches) --- .../tools/slither_format/slither_format.py | 25 ++++++++++++------- 1 file changed, 16 insertions(+), 9 deletions(-) diff --git a/slither/tools/slither_format/slither_format.py b/slither/tools/slither_format/slither_format.py index 6420e76ee..2b015eec2 100644 --- a/slither/tools/slither_format/slither_format.py +++ b/slither/tools/slither_format/slither_format.py @@ -1,5 +1,5 @@ import logging -import os +from pathlib import Path 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 @@ -45,18 +45,24 @@ def slither_format(slither, **kwargs): skip_file_generation = kwargs.get('skip-patch-generation', False) - counter = 0 - export = os.path.join('crytic-export', 'patches') + export = Path('crytic-export', 'patches') - if not os.path.exists(export): - os.makedirs(export) + export.mkdir(parents=True, exist_ok=True) + + counter_result = 0 for result in detector_results: if not 'patches' in result: continue one_line_description = result["description"].split("\n")[0] + + export_result = Path(export, f'{counter_result}') + export_result.mkdir(parents=True, exist_ok=True) + counter_result += 1 + counter = 0 + logger.info(f'Issue: {one_line_description}') - logger.info('Generated:') + logger.info(f'Generated: ({export_result})') for file in result['patches']: original_txt = slither.source_code[file].encode('utf8') patched_txt = original_txt @@ -75,11 +81,12 @@ def slither_format(slither, **kwargs): if not diff: logger.info(f'Impossible to generate patch; empty {result}') continue - path = os.path.join(export, f'fix_{counter}.patch') - logger.info(f'\t- {path}') + filename = f'fix_{counter}.patch' + path = Path(export_result, filename) + logger.info(f'\t- {filename}') with open(path, 'w') as f: f.write(diff) - counter = counter + 1 + counter += 1 # endregion From b38ce905bdf38d2971de284f5c8a83e20f53e47c Mon Sep 17 00:00:00 2001 From: Josselin Date: Thu, 12 Sep 2019 12:28:29 +0200 Subject: [PATCH 167/223] Generate correct patch if 'var ' is used --- .../formatters/naming_convention.py | 25 ++++++++++++++++--- 1 file changed, 21 insertions(+), 4 deletions(-) diff --git a/slither/tools/slither_format/formatters/naming_convention.py b/slither/tools/slither_format/formatters/naming_convention.py index d9199daf4..9d55f0ae8 100644 --- a/slither/tools/slither_format/formatters/naming_convention.py +++ b/slither/tools/slither_format/formatters/naming_convention.py @@ -199,6 +199,19 @@ RE_MAPPING_FROM = b'([a-zA-Z0-9\._\[\]]*)' RE_MAPPING_TO = b'([\=\>\(\) a-zA-Z0-9\._\[\]\ ]*)' RE_MAPPING = b'[ ]*mapping[ ]*\([ ]*' + RE_MAPPING_FROM + b'[ ]*' + b'=>' + b'[ ]*'+ RE_MAPPING_TO + b'\)' + +def _is_var_declaration(slither, filename, start): + ''' + Detect usage of 'var ' for Solidity < 0.5 + :param slither: + :param filename: + :param start: + :return: + ''' + v = 'var ' + return slither.source_code[filename][start:start + len(v)] == v + + def _explore_type(slither, result, target, convert, type, filename_source_code, start, end): if isinstance(type, UserDefinedType): # Patch type based on contract/enum @@ -208,7 +221,10 @@ def _explore_type(slither, result, target, convert, type, filename_source_code, new_str = convert(old_str, slither) loc_start = start - loc_end = loc_start + len(old_str) + if _is_var_declaration(slither, filename_source_code, start): + loc_end = loc_start + len('var') + else: + loc_end = loc_start + len(old_str) create_patch(result, filename_source_code, @@ -226,7 +242,10 @@ def _explore_type(slither, result, target, convert, type, filename_source_code, new_str = convert(old_str, slither) loc_start = start - loc_end = loc_start + len(old_str) + if _is_var_declaration(slither, filename_source_code, start): + loc_end = loc_start + len('var') + else: + loc_end = loc_start + len(old_str) create_patch(result, filename_source_code, @@ -352,13 +371,11 @@ def _explore_variables_declaration(slither, variables, result, target, convert, idx_beginning += - sum([len(c) for c in potential_comments]) old_comment = f'@param {old_str}'.encode('utf8') - print(f'idx beging {idx_beginning}') for line in potential_comments: idx = line.find(old_comment) if idx >=0: loc_start = idx + idx_beginning - print(loc_start) loc_end = loc_start + len(old_comment) new_comment = f'@param {new_str}'.encode('utf8') From a2cdc67c28d6355e7efafcdd79cb682750801bb9 Mon Sep 17 00:00:00 2001 From: Josselin Date: Thu, 12 Sep 2019 12:29:17 +0200 Subject: [PATCH 168/223] Add missing set_expression --- slither/slithir/convert.py | 1 + 1 file changed, 1 insertion(+) diff --git a/slither/slithir/convert.py b/slither/slithir/convert.py index ac3bb4f86..bfd04ca6a 100644 --- a/slither/slithir/convert.py +++ b/slither/slithir/convert.py @@ -708,6 +708,7 @@ def convert_to_solidity_func(ir): call = SolidityFunction('abi.{}()'.format(ir.function_name)) new_ir = SolidityCall(call, ir.nbr_arguments, ir.lvalue, ir.type_call) new_ir.arguments = ir.arguments + new_ir.set_expression(ir.expression) if isinstance(call.return_type, list) and len(call.return_type) == 1: new_ir.lvalue.set_type(call.return_type[0]) else: From 790d4edbf088371c77ef5ae205e5be38ff4eaecf Mon Sep 17 00:00:00 2001 From: Josselin Date: Thu, 12 Sep 2019 13:35:10 +0200 Subject: [PATCH 169/223] Naming convetion formatter: improve function comparison --- slither/tools/slither_format/formatters/naming_convention.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/slither/tools/slither_format/formatters/naming_convention.py b/slither/tools/slither_format/formatters/naming_convention.py index 9d55f0ae8..7717fa086 100644 --- a/slither/tools/slither_format/formatters/naming_convention.py +++ b/slither/tools/slither_format/formatters/naming_convention.py @@ -517,7 +517,7 @@ def _explore_functions(slither, functions, result, target, convert): _explore_modifiers_calls(slither, function, result, target, convert) _explore_irs(slither, function.all_slithir_operations(), result, target, convert) - if function.canonical_name == target.canonical_name: + if isinstance(target, Function) and function.canonical_name == target.canonical_name: old_str = function.name new_str = convert(old_str, slither) From 805b341d538575d1d11532c0948fcddc63c0bdc6 Mon Sep 17 00:00:00 2001 From: Josselin Date: Thu, 12 Sep 2019 13:41:30 +0200 Subject: [PATCH 170/223] Use crytic-compile#master --- setup.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/setup.py b/setup.py index 8cb5f1f77..a3171f989 100644 --- a/setup.py +++ b/setup.py @@ -10,8 +10,8 @@ setup( python_requires='>=3.6', install_requires=['prettytable>=0.7.2', 'pysha3>=1.0.2', - 'crytic-compile>=0.1.3'], - #dependency_links=['git+https://github.com/crytic/crytic-compile.git@master#egg=crytic-compile'], + 'crytic-compile'], + dependency_links=['git+https://github.com/crytic/crytic-compile.git@master#egg=crytic-compile'], license='AGPL-3.0', long_description=open('README.md').read(), entry_points={ From 1dc5f496b6581f0997e7d8c395701cc2ad617870 Mon Sep 17 00:00:00 2001 From: Josselin Date: Mon, 30 Sep 2019 12:16:43 +0200 Subject: [PATCH 171/223] Refactor formatter dir achitecture: - move to slither.formatters.x - add _format in abstract detector - simplify slither-format tool Add slither flag --generate-patches: generate patches and add them to the json Change string / bytes in create_patch functions Remove slither-format --skip-patch-generation flag --- slither/__main__.py | 5 + slither/core/slither_core.py | 16 +++ slither/detectors/abstract_detector.py | 41 ++++++- .../detectors/attributes/const_functions.py | 6 +- .../detectors/attributes/constant_pragma.py | 5 + .../detectors/attributes/incorrect_solc.py | 7 +- .../detectors/functions/external_function.py | 8 +- .../naming_convention/naming_convention.py | 8 +- .../possible_const_state_variables.py | 6 + .../variables/unused_state_variables.py | 5 + .../formatters/__init__.py | 0 .../attributes}/__init__.py | 0 .../attributes/const_functions.py} | 4 +- .../attributes/constant_pragma.py} | 4 +- .../attributes/incorrect_solc.py} | 4 +- .../exceptions.py | 0 slither/formatters/functions/__init__.py | 0 .../functions}/external_function.py | 2 +- .../formatters/naming_convention/__init__.py | 0 .../naming_convention}/naming_convention.py | 4 +- slither/formatters/utils/__init__.py | 0 .../utils/patches.py | 10 +- slither/formatters/variables/__init__.py | 0 .../possible_const_state_variables.py} | 4 +- .../variables/unused_state_variables.py} | 2 +- slither/slither.py | 4 + slither/tools/slither_format/__main__.py | 6 - .../tools/slither_format/slither_format.py | 106 ++---------------- slither/utils/command_line.py | 1 + 29 files changed, 128 insertions(+), 130 deletions(-) rename slither/{tools/slither_format => }/formatters/__init__.py (100%) rename slither/{tools/slither_format/utils => formatters/attributes}/__init__.py (100%) rename slither/{tools/slither_format/formatters/constant_function.py => formatters/attributes/const_functions.py} (93%) rename slither/{tools/slither_format/formatters/pragma.py => formatters/attributes/constant_pragma.py} (95%) rename slither/{tools/slither_format/formatters/solc_version.py => formatters/attributes/incorrect_solc.py} (94%) rename slither/{tools/slither_format => formatters}/exceptions.py (100%) create mode 100644 slither/formatters/functions/__init__.py rename slither/{tools/slither_format/formatters => formatters/functions}/external_function.py (97%) create mode 100644 slither/formatters/naming_convention/__init__.py rename slither/{tools/slither_format/formatters => formatters/naming_convention}/naming_convention.py (99%) create mode 100644 slither/formatters/utils/__init__.py rename slither/{tools/slither_format => formatters}/utils/patches.py (87%) create mode 100644 slither/formatters/variables/__init__.py rename slither/{tools/slither_format/formatters/constable_states.py => formatters/variables/possible_const_state_variables.py} (92%) rename slither/{tools/slither_format/formatters/unused_state.py => formatters/variables/unused_state_variables.py} (94%) diff --git a/slither/__main__.py b/slither/__main__.py index 15532232a..1f02b4b5d 100644 --- a/slither/__main__.py +++ b/slither/__main__.py @@ -380,6 +380,11 @@ def parse_args(detector_classes, printer_classes): action='store_true', default=False) + group_misc.add_argument('--generate-patches', + help='Generate patches (json output only)', + action='store_true', + default=False) + # debugger command parser.add_argument('--debug', help=argparse.SUPPRESS, diff --git a/slither/core/slither_core.py b/slither/core/slither_core.py index f5fc88278..6442b2443 100644 --- a/slither/core/slither_core.py +++ b/slither/core/slither_core.py @@ -35,6 +35,7 @@ class Slither(Context): self._crytic_compile = None + self._generate_patches = False ################################################################################### ################################################################################### @@ -233,4 +234,19 @@ class Slither(Context): @property def crytic_compile(self): return self._crytic_compile + # endregion + ################################################################################### + ################################################################################### + # region Format + ################################################################################### + ################################################################################### + + @property + def generate_patches(self): + return self._generate_patches + + @generate_patches.setter + def generate_patches(self, p): + self._generate_patches = p + # endregion \ No newline at end of file diff --git a/slither/detectors/abstract_detector.py b/slither/detectors/abstract_detector.py index 8a9f6fecf..e7911e4c7 100644 --- a/slither/detectors/abstract_detector.py +++ b/slither/detectors/abstract_detector.py @@ -1,10 +1,10 @@ import abc import re - +from collections import OrderedDict, defaultdict from slither.utils.colors import green, yellow, red from slither.core.source_mapping.source_mapping import SourceMapping -from collections import OrderedDict - +from slither.formatters.exceptions import FormatImpossible +from slither.formatters.utils.patches import apply_patch, create_diff class IncorrectDetectorInitialization(Exception): pass @@ -94,7 +94,8 @@ class AbstractDetector(metaclass=abc.ABCMeta): raise IncorrectDetectorInitialization('CONFIDENCE is not initialized {}'.format(self.__class__.__name__)) def _log(self, info): - self.logger.info(self.color(info)) + if self.logger: + self.logger.info(self.color(info)) @abc.abstractmethod def _detect(self): @@ -115,6 +116,33 @@ class AbstractDetector(metaclass=abc.ABCMeta): info += result['description'] info += 'Reference: {}'.format(self.WIKI) self._log(info) + if self.slither.generate_patches: + for result in results: + try: + self._format(self.slither, result) + if not 'patches' in result: + continue + result['patches_diff'] = dict() + for file in result['patches']: + original_txt = self.slither.source_code[file].encode('utf8') + patched_txt = original_txt + offset = 0 + patches = result['patches'][file] + patches.sort(key=lambda x: x['start']) + if not all(patches[i]['end'] <= patches[i + 1]['end'] for i in range(len(patches) - 1)): + self._log(f'Impossible to generate patch; patches collisions: {patches}') + continue + for patch in patches: + patched_txt, offset = apply_patch(patched_txt, patch, offset) + diff = create_diff(self.slither, original_txt, patched_txt, file) + if not diff: + self._log(f'Impossible to generate patch; empty {result}') + else: + result['patches_diff'][file] = diff + + except FormatImpossible as e: + self._log(f'\nImpossible to patch:\n\t{result["description"]}\t{e}') + if results and self.slither.triage_mode: while True: indexes = input('Results to hide during next runs: "0,1,..." or "All" (enter to not hide results): '.format(len(results))) @@ -310,3 +338,8 @@ class AbstractDetector(metaclass=abc.ABCMeta): {}, additional_fields) d['elements'].append(element) + + @staticmethod + def _format(slither, result): + """Implement format""" + return \ No newline at end of file diff --git a/slither/detectors/attributes/const_functions.py b/slither/detectors/attributes/const_functions.py index 2f217eb97..88598392f 100644 --- a/slither/detectors/attributes/const_functions.py +++ b/slither/detectors/attributes/const_functions.py @@ -3,7 +3,7 @@ Module detecting constant functions Recursively check the called functions """ from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification - +from slither.formatters.attributes.const_functions import format class ConstantFunctions(AbstractDetector): """ @@ -76,3 +76,7 @@ All the calls to `get` revert, breaking Bob's smart contract execution.''' results.append(json) return results + + @staticmethod + def _format(slither, result): + format(slither, result) diff --git a/slither/detectors/attributes/constant_pragma.py b/slither/detectors/attributes/constant_pragma.py index 1f0e905ae..0c2e54bca 100644 --- a/slither/detectors/attributes/constant_pragma.py +++ b/slither/detectors/attributes/constant_pragma.py @@ -3,6 +3,7 @@ """ from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification +from slither.formatters.attributes.constant_pragma import format class ConstantPragma(AbstractDetector): @@ -42,3 +43,7 @@ class ConstantPragma(AbstractDetector): results.append(json) return results + + @staticmethod + def _format(slither, result): + format(slither, result) diff --git a/slither/detectors/attributes/incorrect_solc.py b/slither/detectors/attributes/incorrect_solc.py index c8fb43109..54991722f 100644 --- a/slither/detectors/attributes/incorrect_solc.py +++ b/slither/detectors/attributes/incorrect_solc.py @@ -2,8 +2,9 @@ Check if an incorrect version of solc is used """ -from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification import re +from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification +from slither.formatters.attributes.incorrect_solc import format # group: # 0: ^ > >= < <= (optional) @@ -105,3 +106,7 @@ Use Solidity 0.4.25 or 0.5.3. Consider using the latest version of Solidity for results.append(json) return results + + @staticmethod + def _format(slither, result): + format(slither, result) diff --git a/slither/detectors/functions/external_function.py b/slither/detectors/functions/external_function.py index 732488780..233f24f48 100644 --- a/slither/detectors/functions/external_function.py +++ b/slither/detectors/functions/external_function.py @@ -1,7 +1,9 @@ from slither.detectors.abstract_detector import (AbstractDetector, DetectorClassification) -from slither.slithir.operations import (HighLevelCall, SolidityCall ) +from slither.slithir.operations import SolidityCall from slither.slithir.operations import (InternalCall, InternalDynamicCall) +from slither.formatters.functions.external_function import format + class ExternalFunction(AbstractDetector): """ @@ -193,3 +195,7 @@ class ExternalFunction(AbstractDetector): results.append(json) return results + + @staticmethod + def _format(slither, result): + format(slither, result) diff --git a/slither/detectors/naming_convention/naming_convention.py b/slither/detectors/naming_convention/naming_convention.py index f19fad0fc..3b20a148e 100644 --- a/slither/detectors/naming_convention/naming_convention.py +++ b/slither/detectors/naming_convention/naming_convention.py @@ -1,5 +1,7 @@ -from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification import re +from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification +from slither.formatters.naming_convention.naming_convention import format + class NamingConvention(AbstractDetector): @@ -202,3 +204,7 @@ Solidity defines a [naming convention](https://solidity.readthedocs.io/en/v0.4.2 results.append(json) return results + + @staticmethod + def _format(slither, result): + format(slither, result) diff --git a/slither/detectors/variables/possible_const_state_variables.py b/slither/detectors/variables/possible_const_state_variables.py index 9d30bcfcf..e6c676c16 100644 --- a/slither/detectors/variables/possible_const_state_variables.py +++ b/slither/detectors/variables/possible_const_state_variables.py @@ -7,6 +7,8 @@ from slither.detectors.abstract_detector import AbstractDetector, DetectorClassi from slither.visitors.expression.export_values import ExportValues from slither.core.declarations.solidity_variables import SolidityFunction from slither.core.variables.state_variable import StateVariable +from slither.formatters.variables.possible_const_state_variables import format + class ConstCandidateStateVars(AbstractDetector): """ @@ -94,3 +96,7 @@ class ConstCandidateStateVars(AbstractDetector): results.append(json) return results + + @staticmethod + def _format(slither, result): + format(slither, result) diff --git a/slither/detectors/variables/unused_state_variables.py b/slither/detectors/variables/unused_state_variables.py index 8f03cae8e..99d9ef096 100644 --- a/slither/detectors/variables/unused_state_variables.py +++ b/slither/detectors/variables/unused_state_variables.py @@ -6,6 +6,7 @@ from slither.detectors.abstract_detector import AbstractDetector, DetectorClassi from slither.core.solidity_types import ArrayType from slither.visitors.expression.export_values import ExportValues from slither.core.variables.state_variable import StateVariable +from slither.formatters.variables.unused_state_variables import format class UnusedStateVars(AbstractDetector): """ @@ -67,3 +68,7 @@ class UnusedStateVars(AbstractDetector): results.append(json) return results + + @staticmethod + def _format(slither, result): + format(slither, result) diff --git a/slither/tools/slither_format/formatters/__init__.py b/slither/formatters/__init__.py similarity index 100% rename from slither/tools/slither_format/formatters/__init__.py rename to slither/formatters/__init__.py diff --git a/slither/tools/slither_format/utils/__init__.py b/slither/formatters/attributes/__init__.py similarity index 100% rename from slither/tools/slither_format/utils/__init__.py rename to slither/formatters/attributes/__init__.py diff --git a/slither/tools/slither_format/formatters/constant_function.py b/slither/formatters/attributes/const_functions.py similarity index 93% rename from slither/tools/slither_format/formatters/constant_function.py rename to slither/formatters/attributes/const_functions.py index ee8b4fc2e..ed16c29a6 100644 --- a/slither/tools/slither_format/formatters/constant_function.py +++ b/slither/formatters/attributes/const_functions.py @@ -1,6 +1,6 @@ import re -from ..exceptions import FormatError -from ..utils.patches import create_patch +from slither.formatters.exceptions import FormatError +from slither.formatters.utils.patches import create_patch def format(slither, result): elements = result['elements'] diff --git a/slither/tools/slither_format/formatters/pragma.py b/slither/formatters/attributes/constant_pragma.py similarity index 95% rename from slither/tools/slither_format/formatters/pragma.py rename to slither/formatters/attributes/constant_pragma.py index 5f8d65ede..b039f9895 100644 --- a/slither/tools/slither_format/formatters/pragma.py +++ b/slither/formatters/attributes/constant_pragma.py @@ -1,6 +1,6 @@ import re -from ..exceptions import FormatImpossible -from ..utils.patches import create_patch +from slither.formatters.exceptions import FormatImpossible +from slither.formatters.utils.patches import create_patch # Indicates the recommended versions for replacement REPLACEMENT_VERSIONS = ["^0.4.25", "^0.5.3"] diff --git a/slither/tools/slither_format/formatters/solc_version.py b/slither/formatters/attributes/incorrect_solc.py similarity index 94% rename from slither/tools/slither_format/formatters/solc_version.py rename to slither/formatters/attributes/incorrect_solc.py index fbc3cace2..33013c954 100644 --- a/slither/tools/slither_format/formatters/solc_version.py +++ b/slither/formatters/attributes/incorrect_solc.py @@ -1,6 +1,6 @@ import re -from ..exceptions import FormatImpossible -from ..utils.patches import create_patch +from slither.formatters.exceptions import FormatImpossible +from slither.formatters.utils.patches import create_patch # Indicates the recommended versions for replacement diff --git a/slither/tools/slither_format/exceptions.py b/slither/formatters/exceptions.py similarity index 100% rename from slither/tools/slither_format/exceptions.py rename to slither/formatters/exceptions.py diff --git a/slither/formatters/functions/__init__.py b/slither/formatters/functions/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/slither/tools/slither_format/formatters/external_function.py b/slither/formatters/functions/external_function.py similarity index 97% rename from slither/tools/slither_format/formatters/external_function.py rename to slither/formatters/functions/external_function.py index ffdff7eb4..1eb027902 100644 --- a/slither/tools/slither_format/formatters/external_function.py +++ b/slither/formatters/functions/external_function.py @@ -1,5 +1,5 @@ import re -from ..utils.patches import create_patch +from slither.formatters.utils.patches import create_patch def format(slither, result): elements = result['elements'] diff --git a/slither/formatters/naming_convention/__init__.py b/slither/formatters/naming_convention/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/slither/tools/slither_format/formatters/naming_convention.py b/slither/formatters/naming_convention/naming_convention.py similarity index 99% rename from slither/tools/slither_format/formatters/naming_convention.py rename to slither/formatters/naming_convention/naming_convention.py index 7717fa086..7480524f5 100644 --- a/slither/tools/slither_format/formatters/naming_convention.py +++ b/slither/formatters/naming_convention/naming_convention.py @@ -7,8 +7,8 @@ from slither.core.solidity_types import UserDefinedType, MappingType from slither.core.declarations import Enum, Contract, Structure, Function from slither.core.solidity_types.elementary_type import ElementaryTypeName from slither.core.variables.local_variable import LocalVariable -from ..exceptions import FormatError, FormatImpossible -from ..utils.patches import create_patch +from slither.formatters.exceptions import FormatError, FormatImpossible +from slither.formatters.utils.patches import create_patch logging.basicConfig(level=logging.INFO) logger = logging.getLogger('Slither.Format') diff --git a/slither/formatters/utils/__init__.py b/slither/formatters/utils/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/slither/tools/slither_format/utils/patches.py b/slither/formatters/utils/patches.py similarity index 87% rename from slither/tools/slither_format/utils/patches.py rename to slither/formatters/utils/patches.py index dc8414bd4..d92c42c56 100644 --- a/slither/tools/slither_format/utils/patches.py +++ b/slither/formatters/utils/patches.py @@ -3,10 +3,10 @@ import difflib from collections import defaultdict def create_patch(result, file, start, end, old_str, new_str): - if isinstance(old_str, str): - old_str = old_str.encode('utf8') - if isinstance(new_str, str): - new_str = new_str.encode('utf8') + if isinstance(old_str, bytes): + old_str = old_str.decode('utf8') + if isinstance(new_str, bytes): + new_str = new_str.decode('utf8') p = {"start": start, "end": end, "old_string": old_str, @@ -20,7 +20,7 @@ def create_patch(result, file, start, end, old_str, new_str): def apply_patch(original_txt, patch, offset): patched_txt = original_txt[:int(patch['start'] + offset)] - patched_txt += patch['new_string'] + patched_txt += patch['new_string'].encode('utf8') patched_txt += original_txt[int(patch['end'] + offset):] # Keep the diff of text added or sub, in case of multiple patches diff --git a/slither/formatters/variables/__init__.py b/slither/formatters/variables/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/slither/tools/slither_format/formatters/constable_states.py b/slither/formatters/variables/possible_const_state_variables.py similarity index 92% rename from slither/tools/slither_format/formatters/constable_states.py rename to slither/formatters/variables/possible_const_state_variables.py index d731e7aa5..2c4c378dd 100644 --- a/slither/tools/slither_format/formatters/constable_states.py +++ b/slither/formatters/variables/possible_const_state_variables.py @@ -1,6 +1,6 @@ import re -from ..exceptions import FormatError, FormatImpossible -from ..utils.patches import create_patch +from slither.formatters.exceptions import FormatError, FormatImpossible +from slither.formatters.utils.patches import create_patch def format(slither, result): elements = result['elements'] diff --git a/slither/tools/slither_format/formatters/unused_state.py b/slither/formatters/variables/unused_state_variables.py similarity index 94% rename from slither/tools/slither_format/formatters/unused_state.py rename to slither/formatters/variables/unused_state_variables.py index 0e0f30bde..c1a6e535c 100644 --- a/slither/tools/slither_format/formatters/unused_state.py +++ b/slither/formatters/variables/unused_state_variables.py @@ -1,4 +1,4 @@ -from ..utils.patches import create_patch +from slither.formatters.utils.patches import create_patch def format(slither, result): diff --git a/slither/slither.py b/slither/slither.py index 1152a7ddb..af07cfd93 100644 --- a/slither/slither.py +++ b/slither/slither.py @@ -34,6 +34,7 @@ class Slither(SlitherSolc): filter_paths (list(str)): list of path to filter (default []) triage_mode (bool): if true, switch to triage mode (default false) exclude_dependencies (bool): if true, exclude results that are only related to dependencies + generate_patches (bool): if true, patches are generated (json output only) truffle_ignore (bool): ignore truffle.js presence (default false) truffle_build_directory (str): build truffle directory (default 'build/contracts') @@ -64,6 +65,9 @@ class Slither(SlitherSolc): self._parse_contracts_from_loaded_json(ast, path) self._add_source_code(path) + if kwargs.get('generate_patches', False): + self.generate_patches = True + self._detectors = [] self._printers = [] diff --git a/slither/tools/slither_format/__main__.py b/slither/tools/slither_format/__main__.py index c3e01bf76..82256a5fa 100644 --- a/slither/tools/slither_format/__main__.py +++ b/slither/tools/slither_format/__main__.py @@ -36,12 +36,6 @@ def parse_args(): version='0.1.0', action='version') - parser.add_argument('--skip-patch-generation', - help='Do not generate patch files', - action='store_true', - default=False) - - parser.add_argument('--config-file', help='Provide a config file (default: slither.config.json)', action='store', diff --git a/slither/tools/slither_format/slither_format.py b/slither/tools/slither_format/slither_format.py index 2b015eec2..dd9a745ee 100644 --- a/slither/tools/slither_format/slither_format.py +++ b/slither/tools/slither_format/slither_format.py @@ -7,10 +7,7 @@ from slither.detectors.naming_convention.naming_convention import NamingConventi 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 import unused_state, constable_states, pragma, solc_version, \ - external_function, naming_convention, constant_function -from .utils.patches import apply_patch, create_diff -from .exceptions import FormatError, FormatImpossible +from slither.utils.colors import yellow logging.basicConfig(level=logging.INFO) logger = logging.getLogger('Slither.Format') @@ -37,20 +34,20 @@ def slither_format(slither, **kwargs): for detector in detectors_to_run: slither.register_detector(detector) + slither.generate_patches = True + 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 - apply_detector_results(slither, detector_results) - - skip_file_generation = kwargs.get('skip-patch-generation', False) - export = Path('crytic-export', 'patches') export.mkdir(parents=True, exist_ok=True) counter_result = 0 + logger.info(yellow('slither-format is in beta, carefully review each patch before merging it.')) + for result in detector_results: if not 'patches' in result: continue @@ -63,24 +60,8 @@ def slither_format(slither, **kwargs): logger.info(f'Issue: {one_line_description}') logger.info(f'Generated: ({export_result})') - for file in result['patches']: - original_txt = slither.source_code[file].encode('utf8') - patched_txt = original_txt - offset = 0 - patches = result['patches'][file] - patches.sort(key=lambda x:x['start']) - if not all(patches[i]['end'] <= patches[i+1]['end'] for i in range(len(patches)-1)): - logger.info(f'Impossible to generate patch; patches collisions: {patches}') - continue - for patch in patches: - patched_txt, offset = apply_patch(patched_txt, patch, offset) - diff = create_diff(slither, original_txt, patched_txt, file) - result['paches_diff'] = diff - if skip_file_generation: - continue - if not diff: - logger.info(f'Impossible to generate patch; empty {result}') - continue + + for file, diff, in result['patches_diff'].items(): filename = f'fix_{counter}.patch' path = Path(export_result, filename) logger.info(f'\t- {filename}') @@ -116,79 +97,6 @@ def choose_detectors(detectors_to_run, detectors_to_exclude): raise Exception('Error: {} is not a detector'.format(d)) return cls_detectors_to_run -def apply_detector_results(slither, detector_results): - ''' - Apply slither detector results on contract files to generate patches - ''' - for result in detector_results: - try: - if result['check'] == 'unused-state': - unused_state.format(slither, result) - elif result['check'] == 'solc-version': - solc_version.format(slither, result) - elif result['check'] == 'pragma': - pragma.format(slither, result) - elif result['check'] == 'naming-convention': - naming_convention.format(slither, result) - elif result['check'] == 'external-function': - external_function.format(slither, result) - elif result['check'] == 'constable-states': - constable_states.format(slither, result) - elif result['check'] == 'constant-function': - constant_function.format(slither, result) - else: - raise FormatError(result['check'] + "detector not supported yet.") - except FormatImpossible as e: - logger.info(f'\nImpossible to patch:\n\t{result["description"]}\t{e}') - - -# endregion -################################################################################### -################################################################################### -# region Patch triage (disable) -################################################################################### -################################################################################### - -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 - - # endregion ################################################################################### ################################################################################### diff --git a/slither/utils/command_line.py b/slither/utils/command_line.py index bf9f0c696..ee9b70bbc 100644 --- a/slither/utils/command_line.py +++ b/slither/utils/command_line.py @@ -31,6 +31,7 @@ defaults_flag_in_config = { 'json-types': ','.join(DEFAULT_JSON_OUTPUT_TYPES), 'disable_color': False, 'filter_paths': None, + 'generate_patches': False, # debug command 'legacy_ast': False, 'ignore_return_value': False, From 0c91571295b36ca56b6d27a7dc317106cc978ca0 Mon Sep 17 00:00:00 2001 From: Josselin Date: Tue, 1 Oct 2019 16:51:15 +0200 Subject: [PATCH 172/223] Fix unused state: #333 lead to miss some results --- slither/detectors/variables/unused_state_variables.py | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/slither/detectors/variables/unused_state_variables.py b/slither/detectors/variables/unused_state_variables.py index 8f03cae8e..378a0dbf4 100644 --- a/slither/detectors/variables/unused_state_variables.py +++ b/slither/detectors/variables/unused_state_variables.py @@ -31,8 +31,8 @@ class UnusedStateVars(AbstractDetector): # Get all the variables read in all the functions and modifiers all_functions = (contract.all_functions_called + contract.modifiers) - variables_used = [x.state_variables_read + x.state_variables_written for x in - all_functions] + variables_used = [x.state_variables_read for x in all_functions] + variables_used += [x.state_variables_written for x in all_functions if not x.is_constructor_variables] array_candidates = [x.variables for x in all_functions] array_candidates = [i for sl in array_candidates for i in sl] + contract.state_variables @@ -41,9 +41,12 @@ class UnusedStateVars(AbstractDetector): array_candidates = [i for sl in array_candidates for i in sl] array_candidates = [v for v in array_candidates if isinstance(v, StateVariable)] + + # Flat list variables_used = [item for sublist in variables_used for item in sublist] variables_used = list(set(variables_used + array_candidates)) + # Return the variables unused that are not public return [x for x in contract.variables if x not in variables_used and x.visibility != 'public'] From 256fb1ec0b292a631b7a6faf88c5ea07c16eeedf Mon Sep 17 00:00:00 2001 From: Josselin Date: Wed, 2 Oct 2019 08:36:56 +0200 Subject: [PATCH 173/223] Update etherscan test --- scripts/travis_test_etherscan.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scripts/travis_test_etherscan.sh b/scripts/travis_test_etherscan.sh index 68b03f89f..57b026cc5 100755 --- a/scripts/travis_test_etherscan.sh +++ b/scripts/travis_test_etherscan.sh @@ -18,7 +18,7 @@ fi slither rinkeby:0xFe05820C5A92D9bc906D4A46F662dbeba794d3b7 --solc "./solc-0.4.25" -if [ $? -ne 75 ] +if [ $? -ne 70 ] then echo "Etherscan test failed" exit -1 From 30e8e88a3cde802f6c786c0850dbd4630fa266e1 Mon Sep 17 00:00:00 2001 From: Josselin Date: Wed, 2 Oct 2019 08:38:59 +0200 Subject: [PATCH 174/223] Use cache to speed up dapp travis test Similar to https://github.com/crytic/crytic-compile/pull/42 --- scripts/travis_test_dapp.sh | 3 +++ 1 file changed, 3 insertions(+) diff --git a/scripts/travis_test_dapp.sh b/scripts/travis_test_dapp.sh index 934261312..fa649faad 100755 --- a/scripts/travis_test_dapp.sh +++ b/scripts/travis_test_dapp.sh @@ -7,6 +7,9 @@ cd test_dapp curl https://nixos.org/nix/install | sh . "$HOME/.nix-profile/etc/profile.d/nix.sh" +nix-env -iA nixpkgs.cachix +cachix use dapp + git clone --recursive https://github.com/dapphub/dapptools $HOME/.dapp/dapptools nix-env -f $HOME/.dapp/dapptools -iA dapp seth solc hevm ethsign From 28b7bb35ef6b8929528c02a6eccf0cd81dac0179 Mon Sep 17 00:00:00 2001 From: Josselin Date: Wed, 2 Oct 2019 09:01:27 +0200 Subject: [PATCH 175/223] Update dapp test --- scripts/travis_test_dapp.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scripts/travis_test_dapp.sh b/scripts/travis_test_dapp.sh index fa649faad..05a0b823f 100755 --- a/scripts/travis_test_dapp.sh +++ b/scripts/travis_test_dapp.sh @@ -17,7 +17,7 @@ dapp init slither . -if [ $? -eq 23 ] +if [ $? -eq 22 ] then exit 0 fi From f4e2505c072f685d380a29d0389efef425ccc546 Mon Sep 17 00:00:00 2001 From: Josselin Date: Wed, 2 Oct 2019 14:07:07 +0200 Subject: [PATCH 176/223] slither-flat: Add support for --contract --- slither/tools/flattening/flattening.py | 31 +++++++++++++++++--------- 1 file changed, 20 insertions(+), 11 deletions(-) diff --git a/slither/tools/flattening/flattening.py b/slither/tools/flattening/flattening.py index 2f6a2ecd5..6acd8200a 100644 --- a/slither/tools/flattening/flattening.py +++ b/slither/tools/flattening/flattening.py @@ -125,22 +125,31 @@ class Flattening: exported.add(contract.name) list_contract.append(self._source_codes[contract]) + def _export(self, contract, ret): + self._export_contract(contract, set(), ret) + path = Path(self.DEFAULT_EXPORT_PATH, f'{contract.name}.sol') + logger.info(f'Export {path}') + with open(path, 'w') as f: + if self._slither.solc_version: + f.write(f'pragma solidity {self._slither.solc_version};\n') + if self._use_abi_encoder_v2: + f.write('pragma experimental ABIEncoderV2;\n') + f.write('\n'.join(ret)) + f.write('\n') def export(self, target=None): if not self.DEFAULT_EXPORT_PATH.exists(): self.DEFAULT_EXPORT_PATH.mkdir(parents=True) + ret = [] if target is None: for contract in self._slither.contracts_derived: - ret = [] - self._export_contract(contract, set(), ret) - path = Path(self.DEFAULT_EXPORT_PATH, f'{contract.name}.sol') - logger.info(f'Export {path}') - with open(path, 'w') as f: - if self._slither.solc_version: - f.write(f'pragma solidity {self._slither.solc_version};\n') - if self._use_abi_encoder_v2: - f.write('pragma experimental ABIEncoderV2;\n') - f.write('\n'.join(ret)) - f.write('\n') + self._export(contract, ret) + else: + contract = self._slither.get_contract_from_name(target) + if contract is None: + logger.error(f'{target} not found') + else: + self._export(contract, ret) + From f916ee544db192973f3c5fa0a2e15841e37d1e9b Mon Sep 17 00:00:00 2001 From: Josselin Date: Wed, 2 Oct 2019 15:54:04 +0200 Subject: [PATCH 177/223] Clean slither-format directory --- slither/tools/slither_format/README.md | 62 - slither/tools/slither_format/tests/.gitignore | 1 - .../tools/slither_format/tests/__init__.py | 0 ...F879cb30FE243b4Dfee438691c04_GasToken2.sol | 332 --- ...765f14f10a1a1b08334ef45_StoxSmartToken.sol | 880 ------- ...eed7a43e16e3083bc8a4287a_OriginalToken.sol | 241 -- ...67c080e9d511a34d36152c0_MultiSigWallet.sol | 367 --- ...2b8ed15e9fedaacfcef1fad27_ZilliqaToken.sol | 349 --- ...ead5deae237070f9587f8e7a266d_KittyCore.sol | 2009 ---------------- ...64061dd23f8209f804a3b8ad2f2_FoMo3Dlong.sol | 2058 ----------------- ...15a7d984b8c71c15e82b7_EnclavesDEXProxy.sol | 286 --- ...d8f85f41cfb6de49b9db29_BancorConverter.sol | 1011 -------- ...ea7f106ecbd1850e406adc41b51_OceanToken.sol | 454 ---- .../slither_format/tests/runSlitherFormat.py | 24 - .../slither_format/tests/run_all_tests.py | 22 - .../tests/test_constable_states.py | 57 - .../tests/test_constant_function.py | 65 - .../tests/test_data/const_state_variables.sol | 52 - .../tests/test_data/constant-0.5.1.sol | 18 - .../tests/test_data/constant.sol | 25 - .../tests/test_data/detector_combinations.sol | 48 - .../tests/test_data/external_function.sol | 121 - .../tests/test_data/external_function_2.sol | 55 - .../test_data/external_function_import.sol | 7 - .../tests/test_data/naming_convention.sol | 108 - .../test_data/naming_convention_contract.sol | 51 - .../test_data/naming_convention_enum.sol | 53 - .../test_data/naming_convention_event.sol | 40 - .../test_data/naming_convention_function.sol | 33 - .../test_data/naming_convention_modifier.sol | 53 - .../test_data/naming_convention_parameter.sol | 47 - .../naming_convention_state_variable.sol | 37 - .../test_data/naming_convention_structure.sol | 58 - .../tests/test_data/pragma.0.4.23.sol | 1 - .../tests/test_data/pragma.0.4.24.sol | 5 - .../tests/test_data/pragma.0.5.2.sol | 1 - .../tests/test_data/pragma.0.5.4.sol | 5 - .../test_data/solc_version_incorrect1.sol | 5 - .../test_data/solc_version_incorrect2.sol | 5 - .../test_data/solc_version_incorrect3.sol | 5 - .../test_data/solc_version_incorrect4.sol | 5 - .../tests/test_data/unicode.sol | 4 - .../tests/test_data/unused_state.sol | 13 - .../tests/test_detector_combinations.py | 42 - .../tests/test_external_function.py | 80 - .../tests/test_naming_convention.py | 409 ---- .../tools/slither_format/tests/test_pragma.py | 71 - .../slither_format/tests/test_solc_version.py | 116 - .../slither_format/tests/test_unicode.py | 37 - .../tests/test_unused_state_vars.py | 37 - 50 files changed, 9865 deletions(-) delete mode 100644 slither/tools/slither_format/README.md delete mode 100644 slither/tools/slither_format/tests/.gitignore delete mode 100644 slither/tools/slither_format/tests/__init__.py delete mode 100644 slither/tools/slither_format/tests/real_world/0x0000000000b3F879cb30FE243b4Dfee438691c04_GasToken2.sol delete mode 100644 slither/tools/slither_format/tests/real_world/0x006bea43baa3f7a6f765f14f10a1a1b08334ef45_StoxSmartToken.sol delete mode 100644 slither/tools/slither_format/tests/real_world/0x0235fe624e044a05eed7a43e16e3083bc8a4287a_OriginalToken.sol delete mode 100644 slither/tools/slither_format/tests/real_world/0x05cf67329a262818e67c080e9d511a34d36152c0_MultiSigWallet.sol delete mode 100644 slither/tools/slither_format/tests/real_world/0x05f4a42e251f2d52b8ed15e9fedaacfcef1fad27_ZilliqaToken.sol delete mode 100644 slither/tools/slither_format/tests/real_world/0x06012c8cf97bead5deae237070f9587f8e7a266d_KittyCore.sol delete mode 100644 slither/tools/slither_format/tests/real_world/0x5d0d76787d9d564061dd23f8209f804a3b8ad2f2_FoMo3Dlong.sol delete mode 100644 slither/tools/slither_format/tests/real_world/0xbf45f4280cfbe7c2d2515a7d984b8c71c15e82b7_EnclavesDEXProxy.sol delete mode 100644 slither/tools/slither_format/tests/real_world/0xc6725ae749677f21e4d8f85f41cfb6de49b9db29_BancorConverter.sol delete mode 100644 slither/tools/slither_format/tests/real_world/0xf5ed2dc77f0d1ea7f106ecbd1850e406adc41b51_OceanToken.sol delete mode 100644 slither/tools/slither_format/tests/runSlitherFormat.py delete mode 100644 slither/tools/slither_format/tests/run_all_tests.py delete mode 100644 slither/tools/slither_format/tests/test_constable_states.py delete mode 100644 slither/tools/slither_format/tests/test_constant_function.py delete mode 100644 slither/tools/slither_format/tests/test_data/const_state_variables.sol delete mode 100644 slither/tools/slither_format/tests/test_data/constant-0.5.1.sol delete mode 100644 slither/tools/slither_format/tests/test_data/constant.sol delete mode 100644 slither/tools/slither_format/tests/test_data/detector_combinations.sol delete mode 100644 slither/tools/slither_format/tests/test_data/external_function.sol delete mode 100644 slither/tools/slither_format/tests/test_data/external_function_2.sol delete mode 100644 slither/tools/slither_format/tests/test_data/external_function_import.sol delete mode 100644 slither/tools/slither_format/tests/test_data/naming_convention.sol delete mode 100644 slither/tools/slither_format/tests/test_data/naming_convention_contract.sol delete mode 100644 slither/tools/slither_format/tests/test_data/naming_convention_enum.sol delete mode 100644 slither/tools/slither_format/tests/test_data/naming_convention_event.sol delete mode 100644 slither/tools/slither_format/tests/test_data/naming_convention_function.sol delete mode 100644 slither/tools/slither_format/tests/test_data/naming_convention_modifier.sol delete mode 100644 slither/tools/slither_format/tests/test_data/naming_convention_parameter.sol delete mode 100644 slither/tools/slither_format/tests/test_data/naming_convention_state_variable.sol delete mode 100644 slither/tools/slither_format/tests/test_data/naming_convention_structure.sol delete mode 100644 slither/tools/slither_format/tests/test_data/pragma.0.4.23.sol delete mode 100644 slither/tools/slither_format/tests/test_data/pragma.0.4.24.sol delete mode 100644 slither/tools/slither_format/tests/test_data/pragma.0.5.2.sol delete mode 100644 slither/tools/slither_format/tests/test_data/pragma.0.5.4.sol delete mode 100644 slither/tools/slither_format/tests/test_data/solc_version_incorrect1.sol delete mode 100644 slither/tools/slither_format/tests/test_data/solc_version_incorrect2.sol delete mode 100644 slither/tools/slither_format/tests/test_data/solc_version_incorrect3.sol delete mode 100644 slither/tools/slither_format/tests/test_data/solc_version_incorrect4.sol delete mode 100644 slither/tools/slither_format/tests/test_data/unicode.sol delete mode 100644 slither/tools/slither_format/tests/test_data/unused_state.sol delete mode 100644 slither/tools/slither_format/tests/test_detector_combinations.py delete mode 100644 slither/tools/slither_format/tests/test_external_function.py delete mode 100644 slither/tools/slither_format/tests/test_naming_convention.py delete mode 100644 slither/tools/slither_format/tests/test_pragma.py delete mode 100644 slither/tools/slither_format/tests/test_solc_version.py delete mode 100644 slither/tools/slither_format/tests/test_unicode.py delete mode 100644 slither/tools/slither_format/tests/test_unused_state_vars.py diff --git a/slither/tools/slither_format/README.md b/slither/tools/slither_format/README.md deleted file mode 100644 index d4fa841dd..000000000 --- a/slither/tools/slither_format/README.md +++ /dev/null @@ -1,62 +0,0 @@ -# Slither-format: Automatic Code Improvements - -Slither-format is a Slither utility tool which uses Slither detectors to identify code patterns of concern (w.r.t security, readability and optimisation) and automatically fix those code patterns with suggested changes. - -Slither detectors highlight names, context and source-mapping of code constructs which are then used by Slither-format to programmatically locate those constructs in the Solidity files and then replace them with changes based on best practices. Lexical analysis for identification of such constructs is confined to the smallest possible region to avoid conflicts with similarly named constructs (with potentially different types or signatures) in other scopes, functions or contracts within the same file (because of shadowing, overloading etc.). - -## Features - -* Removes declarations of unused state variables -* Changes the visibility of `public` (explicit or implicit until solc 0.5.0) functions to `external` where possible -* Declares state variables as `constant` where possible -* Removes `pure`/`view`/`constant` attributes of functions when they are incorrectly used -* Replaces old/buggy/too-recent versions of `solc` with either `0.4.25` or `0.5.3` -* Replaces use of different `solc` versions with either `0.4.25` or `0.5.3` -* Replaces names of various program constructs to adhere to Solidity [naming convention](https://solidity.readthedocs.io/en/v0.4.25/style-guide.html#naming-conventions): - + Contract names are converted to CapWords in contract definitions and uses - + Structure names are converted to CapWords in structure declarations and uses - + Event names are converted to CapWords in event declarations and calls - + Enum names are converted to CapWords in enum declarations and uses - + State variables: - + If constant, are converted to UPPERCASE - + If private, are converted to mixedCase with underscore - + If not private, are converted to mixedCase - + Function names are converted to mixedCase in function definitions and calls - + Function parameters are converted to CapWords beginning with underscores in parameter declaration and uses - + Function modifiers are converted to mixedCase in modifier definitions and calls - -## Usage - -Run Slither-format on a single file: - -``` -$ slither-format ./utils/slither_format/tests/test_data/constant.sol -``` - -This produces a `constant.sol.format` file which has all the feature replacements. It also produces a `constant.sol.format.patch` file which is a `git` compatible patch file that can be used to apply format diffs to the original file. - -## Dependencies - -Slither-format requires Slither and all its dependencies - -## To-do List of Known Limitations - -1. Naming convention formatting on parameter uses does not work for NatSpec @param attributes. -2. Naming convention formatting on parameter uses does not work for variables used as indices on LHS (e.g. `_to` in `balances[_to] = 100`). -3. Overlapping patches are ignored now - Apply the more important patch based on heuristics or user input. -4. Other to-do's as commented in the code. - -## Developer Testing - -``` -$ python3 ./slither_format/tests/test_unused_state_vars.py -$ python3 ./slither_format/tests/test_external_function.py -$ python3 ./slither_format/tests/test_constable_states.py -$ python3 ./slither_format/tests/test_constant_function.py -$ python3 ./slither_format/tests/test_solc_version.py -$ python3 ./slither_format/tests/test_pragma.py -$ python3 ./slither_format/tests/test_naming_convention.py (Has one expected failure because of limitation #2.) -$ python3 ./slither_format/tests/test_detector_combinations.py -$ python3 ./slither_format/tests/run_all_tests.py -$ python3 ./slither_format/tests/runSlitherFormat.py -``` diff --git a/slither/tools/slither_format/tests/.gitignore b/slither/tools/slither_format/tests/.gitignore deleted file mode 100644 index 9f1f4d954..000000000 --- a/slither/tools/slither_format/tests/.gitignore +++ /dev/null @@ -1 +0,0 @@ -*.patch.* \ No newline at end of file diff --git a/slither/tools/slither_format/tests/__init__.py b/slither/tools/slither_format/tests/__init__.py deleted file mode 100644 index e69de29bb..000000000 diff --git a/slither/tools/slither_format/tests/real_world/0x0000000000b3F879cb30FE243b4Dfee438691c04_GasToken2.sol b/slither/tools/slither_format/tests/real_world/0x0000000000b3F879cb30FE243b4Dfee438691c04_GasToken2.sol deleted file mode 100644 index d122420cf..000000000 --- a/slither/tools/slither_format/tests/real_world/0x0000000000b3F879cb30FE243b4Dfee438691c04_GasToken2.sol +++ /dev/null @@ -1,332 +0,0 @@ -pragma solidity ^0.4.10; - -contract GasToken2 { - ////////////////////////////////////////////////////////////////////////// - // RLP.sol - // Due to some unexplained bug, we get a slightly different bytecode if - // we use an import, and are then unable to verify the code in Etherscan - ////////////////////////////////////////////////////////////////////////// - - uint256 constant ADDRESS_BYTES = 20; - uint256 constant MAX_SINGLE_BYTE = 128; - uint256 constant MAX_NONCE = 256**9 - 1; - - // count number of bytes required to represent an unsigned integer - function count_bytes(uint256 n) constant internal returns (uint256 c) { - uint i = 0; - uint mask = 1; - while (n >= mask) { - i += 1; - mask *= 256; - } - - return i; - } - - function mk_contract_address(address a, uint256 n) constant internal returns (address rlp) { - /* - * make sure the RLP encoding fits in one word: - * total_length 1 byte - * address_length 1 byte - * address 20 bytes - * nonce_length 1 byte (or 0) - * nonce 1-9 bytes - * ========== - * 24-32 bytes - */ - require(n <= MAX_NONCE); - - // number of bytes required to write down the nonce - uint256 nonce_bytes; - // length in bytes of the RLP encoding of the nonce - uint256 nonce_rlp_len; - - if (0 < n && n < MAX_SINGLE_BYTE) { - // nonce fits in a single byte - // RLP(nonce) = nonce - nonce_bytes = 1; - nonce_rlp_len = 1; - } else { - // RLP(nonce) = [num_bytes_in_nonce nonce] - nonce_bytes = count_bytes(n); - nonce_rlp_len = nonce_bytes + 1; - } - - // [address_length(1) address(20) nonce_length(0 or 1) nonce(1-9)] - uint256 tot_bytes = 1 + ADDRESS_BYTES + nonce_rlp_len; - - // concatenate all parts of the RLP encoding in the leading bytes of - // one 32-byte word - uint256 word = ((192 + tot_bytes) * 256**31) + - ((128 + ADDRESS_BYTES) * 256**30) + - (uint256(a) * 256**10); - - if (0 < n && n < MAX_SINGLE_BYTE) { - word += n * 256**9; - } else { - word += (128 + nonce_bytes) * 256**9; - word += n * 256**(9 - nonce_bytes); - } - - uint256 hash; - - assembly { - let mem_start := mload(0x40) // get a pointer to free memory - mstore(0x40, add(mem_start, 0x20)) // update the pointer - - mstore(mem_start, word) // store the rlp encoding - hash := sha3(mem_start, - add(tot_bytes, 1)) // hash the rlp encoding - } - - // interpret hash as address (20 least significant bytes) - return address(hash); - } - - ////////////////////////////////////////////////////////////////////////// - // Generic ERC20 - ////////////////////////////////////////////////////////////////////////// - - // owner -> amount - mapping(address => uint256) s_balances; - // owner -> spender -> max amount - mapping(address => mapping(address => uint256)) s_allowances; - - event Transfer(address indexed from, address indexed to, uint256 value); - - event Approval(address indexed owner, address indexed spender, uint256 value); - - // Spec: Get the account balance of another account with address `owner` - function balanceOf(address owner) public constant returns (uint256 balance) { - return s_balances[owner]; - } - - function internalTransfer(address from, address to, uint256 value) internal returns (bool success) { - if (value <= s_balances[from]) { - s_balances[from] -= value; - s_balances[to] += value; - Transfer(from, to, value); - return true; - } else { - return false; - } - } - - // Spec: Send `value` amount of tokens to address `to` - function transfer(address to, uint256 value) public returns (bool success) { - address from = msg.sender; - return internalTransfer(from, to, value); - } - - // Spec: Send `value` amount of tokens from address `from` to address `to` - function transferFrom(address from, address to, uint256 value) public returns (bool success) { - address spender = msg.sender; - if(value <= s_allowances[from][spender] && internalTransfer(from, to, value)) { - s_allowances[from][spender] -= value; - return true; - } else { - return false; - } - } - - // Spec: Allow `spender` to withdraw from your account, multiple times, up - // to the `value` amount. If this function is called again it overwrites the - // current allowance with `value`. - function approve(address spender, uint256 value) public returns (bool success) { - address owner = msg.sender; - if (value != 0 && s_allowances[owner][spender] != 0) { - return false; - } - s_allowances[owner][spender] = value; - Approval(owner, spender, value); - return true; - } - - // Spec: Returns the `amount` which `spender` is still allowed to withdraw - // from `owner`. - // What if the allowance is higher than the balance of the `owner`? - // Callers should be careful to use min(allowance, balanceOf) to make sure - // that the allowance is actually present in the account! - function allowance(address owner, address spender) public constant returns (uint256 remaining) { - return s_allowances[owner][spender]; - } - - ////////////////////////////////////////////////////////////////////////// - // GasToken specifics - ////////////////////////////////////////////////////////////////////////// - - uint8 constant public decimals = 2; - string constant public name = "Gastoken.io"; - string constant public symbol = "GST2"; - - // We build a queue of nonces at which child contracts are stored. s_head is - // the nonce at the head of the queue, s_tail is the nonce behind the tail - // of the queue. The queue grows at the head and shrinks from the tail. - // Note that when and only when a contract CREATEs another contract, the - // creating contract's nonce is incremented. - // The first child contract is created with nonce == 1, the second child - // contract is created with nonce == 2, and so on... - // For example, if there are child contracts at nonces [2,3,4], - // then s_head == 4 and s_tail == 1. If there are no child contracts, - // s_head == s_tail. - uint256 s_head; - uint256 s_tail; - - // totalSupply gives the number of tokens currently in existence - // Each token corresponds to one child contract that can be SELFDESTRUCTed - // for a gas refund. - function totalSupply() public constant returns (uint256 supply) { - return s_head - s_tail; - } - - // Creates a child contract that can only be destroyed by this contract. - function makeChild() internal returns (address addr) { - assembly { - // EVM assembler of runtime portion of child contract: - // ;; Pseudocode: if (msg.sender != 0x0000000000b3f879cb30fe243b4dfee438691c04) { throw; } - // ;; suicide(msg.sender) - // PUSH15 0xb3f879cb30fe243b4dfee438691c04 ;; hardcoded address of this contract - // CALLER - // XOR - // PC - // JUMPI - // CALLER - // SELFDESTRUCT - // Or in binary: 6eb3f879cb30fe243b4dfee438691c043318585733ff - // Since the binary is so short (22 bytes), we can get away - // with a very simple initcode: - // PUSH22 0x6eb3f879cb30fe243b4dfee438691c043318585733ff - // PUSH1 0 - // MSTORE ;; at this point, memory locations mem[10] through - // ;; mem[31] contain the runtime portion of the child - // ;; contract. all that's left to do is to RETURN this - // ;; chunk of memory. - // PUSH1 22 ;; length - // PUSH1 10 ;; offset - // RETURN - // Or in binary: 756eb3f879cb30fe243b4dfee438691c043318585733ff6000526016600af3 - // Almost done! All we have to do is put this short (31 bytes) blob into - // memory and call CREATE with the appropriate offsets. - let solidity_free_mem_ptr := mload(0x40) - mstore(solidity_free_mem_ptr, 0x00756eb3f879cb30fe243b4dfee438691c043318585733ff6000526016600af3) - addr := create(0, add(solidity_free_mem_ptr, 1), 31) - } - } - - // Mints `value` new sub-tokens (e.g. cents, pennies, ...) by creating `value` - // new child contracts. The minted tokens are owned by the caller of this - // function. - function mint(uint256 value) public { - for (uint256 i = 0; i < value; i++) { - makeChild(); - } - s_head += value; - s_balances[msg.sender] += value; - } - - // Destroys `value` child contracts and updates s_tail. - // - // This function is affected by an issue in solc: https://github.com/ethereum/solidity/issues/2999 - // The `mk_contract_address(this, i).call();` doesn't forward all available gas, but only GAS - 25710. - // As a result, when this line is executed with e.g. 30000 gas, the callee will have less than 5000 gas - // available and its SELFDESTRUCT operation will fail leading to no gas refund occurring. - // The remaining ~29000 gas left after the call is enough to update s_tail and the caller's balance. - // Hence tokens will have been destroyed without a commensurate gas refund. - // Fortunately, there is a simple workaround: - // Whenever you call free, freeUpTo, freeFrom, or freeUpToFrom, ensure that you pass at least - // 25710 + `value` * (1148 + 5722 + 150) gas. (It won't all be used) - function destroyChildren(uint256 value) internal { - uint256 tail = s_tail; - // tail points to slot behind the last contract in the queue - for (uint256 i = tail + 1; i <= tail + value; i++) { - mk_contract_address(this, i).call(); - } - - s_tail = tail + value; - } - - // Frees `value` sub-tokens (e.g. cents, pennies, ...) belonging to the - // caller of this function by destroying `value` child contracts, which - // will trigger a partial gas refund. - // You should ensure that you pass at least 25710 + `value` * (1148 + 5722 + 150) gas - // when calling this function. For details, see the comment above `destroyChilden`. - function free(uint256 value) public returns (bool success) { - uint256 from_balance = s_balances[msg.sender]; - if (value > from_balance) { - return false; - } - - destroyChildren(value); - - s_balances[msg.sender] = from_balance - value; - - return true; - } - - // Frees up to `value` sub-tokens. Returns how many tokens were freed. - // Otherwise, identical to free. - // You should ensure that you pass at least 25710 + `value` * (1148 + 5722 + 150) gas - // when calling this function. For details, see the comment above `destroyChilden`. - function freeUpTo(uint256 value) public returns (uint256 freed) { - uint256 from_balance = s_balances[msg.sender]; - if (value > from_balance) { - value = from_balance; - } - - destroyChildren(value); - - s_balances[msg.sender] = from_balance - value; - - return value; - } - - // Frees `value` sub-tokens owned by address `from`. Requires that `msg.sender` - // has been approved by `from`. - // You should ensure that you pass at least 25710 + `value` * (1148 + 5722 + 150) gas - // when calling this function. For details, see the comment above `destroyChilden`. - function freeFrom(address from, uint256 value) public returns (bool success) { - address spender = msg.sender; - uint256 from_balance = s_balances[from]; - if (value > from_balance) { - return false; - } - - mapping(address => uint256) from_allowances = s_allowances[from]; - uint256 spender_allowance = from_allowances[spender]; - if (value > spender_allowance) { - return false; - } - - destroyChildren(value); - - s_balances[from] = from_balance - value; - from_allowances[spender] = spender_allowance - value; - - return true; - } - - // Frees up to `value` sub-tokens owned by address `from`. Returns how many tokens were freed. - // Otherwise, identical to `freeFrom`. - // You should ensure that you pass at least 25710 + `value` * (1148 + 5722 + 150) gas - // when calling this function. For details, see the comment above `destroyChilden`. - function freeFromUpTo(address from, uint256 value) public returns (uint256 freed) { - address spender = msg.sender; - uint256 from_balance = s_balances[from]; - if (value > from_balance) { - value = from_balance; - } - - mapping(address => uint256) from_allowances = s_allowances[from]; - uint256 spender_allowance = from_allowances[spender]; - if (value > spender_allowance) { - value = spender_allowance; - } - - destroyChildren(value); - - s_balances[from] = from_balance - value; - from_allowances[spender] = spender_allowance - value; - - return value; - } -} \ No newline at end of file diff --git a/slither/tools/slither_format/tests/real_world/0x006bea43baa3f7a6f765f14f10a1a1b08334ef45_StoxSmartToken.sol b/slither/tools/slither_format/tests/real_world/0x006bea43baa3f7a6f765f14f10a1a1b08334ef45_StoxSmartToken.sol deleted file mode 100644 index db6b2796b..000000000 --- a/slither/tools/slither_format/tests/real_world/0x006bea43baa3f7a6f765f14f10a1a1b08334ef45_StoxSmartToken.sol +++ /dev/null @@ -1,880 +0,0 @@ -pragma solidity ^0.4.11; - -/* - Owned contract interface -*/ -contract IOwned { - // this function isn't abstract since the compiler emits automatically generated getter functions as external - function owner() public constant returns (address owner) { owner; } - - function transferOwnership(address _newOwner) public; - function acceptOwnership() public; -} - -/* - ERC20 Standard Token interface -*/ -contract IERC20Token { - // these functions aren't abstract since the compiler emits automatically generated getter functions as external - function name() public constant returns (string name) { name; } - function symbol() public constant returns (string symbol) { symbol; } - function decimals() public constant returns (uint8 decimals) { decimals; } - function totalSupply() public constant returns (uint256 totalSupply) { totalSupply; } - function balanceOf(address _owner) public constant returns (uint256 balance) { _owner; balance; } - function allowance(address _owner, address _spender) public constant returns (uint256 remaining) { _owner; _spender; remaining; } - - function transfer(address _to, uint256 _value) public returns (bool success); - function transferFrom(address _from, address _to, uint256 _value) public returns (bool success); - function approve(address _spender, uint256 _value) public returns (bool success); -} - -/* - Token Holder interface -*/ -contract ITokenHolder is IOwned { - function withdrawTokens(IERC20Token _token, address _to, uint256 _amount) public; -} - -/* - Smart Token interface -*/ -contract ISmartToken is ITokenHolder, IERC20Token { - function disableTransfers(bool _disable) public; - function issue(address _to, uint256 _amount) public; - function destroy(address _from, uint256 _amount) public; -} - -/* - Overflow protected math functions -*/ -contract SafeMath { - /** - constructor - */ - function SafeMath() { - } - - /** - @dev returns the sum of _x and _y, asserts if the calculation overflows - - @param _x value 1 - @param _y value 2 - - @return sum - */ - function safeAdd(uint256 _x, uint256 _y) internal returns (uint256) { - uint256 z = _x + _y; - assert(z >= _x); - return z; - } - - /** - @dev returns the difference of _x minus _y, asserts if the subtraction results in a negative number - - @param _x minuend - @param _y subtrahend - - @return difference - */ - function safeSub(uint256 _x, uint256 _y) internal returns (uint256) { - assert(_x >= _y); - return _x - _y; - } - - /** - @dev returns the product of multiplying _x by _y, asserts if the calculation overflows - - @param _x factor 1 - @param _y factor 2 - - @return product - */ - function safeMul(uint256 _x, uint256 _y) internal returns (uint256) { - uint256 z = _x * _y; - assert(_x == 0 || z / _x == _y); - return z; - } -} - -/** - ERC20 Standard Token implementation -*/ -contract ERC20Token is IERC20Token, SafeMath { - string public standard = 'Token 0.1'; - string public name = ''; - string public symbol = ''; - uint8 public decimals = 0; - uint256 public totalSupply = 0; - mapping (address => uint256) public balanceOf; - mapping (address => mapping (address => uint256)) public allowance; - - event Transfer(address indexed _from, address indexed _to, uint256 _value); - event Approval(address indexed _owner, address indexed _spender, uint256 _value); - - /** - @dev constructor - - @param _name token name - @param _symbol token symbol - @param _decimals decimal points, for display purposes - */ - function ERC20Token(string _name, string _symbol, uint8 _decimals) { - require(bytes(_name).length > 0 && bytes(_symbol).length > 0); // validate input - - name = _name; - symbol = _symbol; - decimals = _decimals; - } - - // validates an address - currently only checks that it isn't null - modifier validAddress(address _address) { - require(_address != 0x0); - _; - } - - /** - @dev send coins - throws on any error rather then return a false flag to minimize user errors - - @param _to target address - @param _value transfer amount - - @return true if the transfer was successful, false if it wasn't - */ - function transfer(address _to, uint256 _value) - public - validAddress(_to) - returns (bool success) - { - balanceOf[msg.sender] = safeSub(balanceOf[msg.sender], _value); - balanceOf[_to] = safeAdd(balanceOf[_to], _value); - Transfer(msg.sender, _to, _value); - return true; - } - - /** - @dev an account/contract attempts to get the coins - throws on any error rather then return a false flag to minimize user errors - - @param _from source address - @param _to target address - @param _value transfer amount - - @return true if the transfer was successful, false if it wasn't - */ - function transferFrom(address _from, address _to, uint256 _value) - public - validAddress(_from) - validAddress(_to) - returns (bool success) - { - allowance[_from][msg.sender] = safeSub(allowance[_from][msg.sender], _value); - balanceOf[_from] = safeSub(balanceOf[_from], _value); - balanceOf[_to] = safeAdd(balanceOf[_to], _value); - Transfer(_from, _to, _value); - return true; - } - - /** - @dev allow another account/contract to spend some tokens on your behalf - throws on any error rather then return a false flag to minimize user errors - - also, to minimize the risk of the approve/transferFrom attack vector - (see https://docs.google.com/document/d/1YLPtQxZu1UAvO9cZ1O2RPXBbT0mooh4DYKjA_jp-RLM/), approve has to be called twice - in 2 separate transactions - once to change the allowance to 0 and secondly to change it to the new allowance value - - @param _spender approved address - @param _value allowance amount - - @return true if the approval was successful, false if it wasn't - */ - function approve(address _spender, uint256 _value) - public - validAddress(_spender) - returns (bool success) - { - // if the allowance isn't 0, it can only be updated to 0 to prevent an allowance change immediately after withdrawal - require(_value == 0 || allowance[msg.sender][_spender] == 0); - - allowance[msg.sender][_spender] = _value; - Approval(msg.sender, _spender, _value); - return true; - } -} - -/* - Provides support and utilities for contract ownership -*/ -contract Owned is IOwned { - address public owner; - address public newOwner; - - event OwnerUpdate(address _prevOwner, address _newOwner); - - /** - @dev constructor - */ - function Owned() { - owner = msg.sender; - } - - // allows execution by the owner only - modifier ownerOnly { - assert(msg.sender == owner); - _; - } - - /** - @dev allows transferring the contract ownership - the new owner still need to accept the transfer - can only be called by the contract owner - - @param _newOwner new contract owner - */ - function transferOwnership(address _newOwner) public ownerOnly { - require(_newOwner != owner); - newOwner = _newOwner; - } - - /** - @dev used by a new owner to accept an ownership transfer - */ - function acceptOwnership() public { - require(msg.sender == newOwner); - OwnerUpdate(owner, newOwner); - owner = newOwner; - newOwner = 0x0; - } -} - -/* - We consider every contract to be a 'token holder' since it's currently not possible - for a contract to deny receiving tokens. - - The TokenHolder's contract sole purpose is to provide a safety mechanism that allows - the owner to send tokens that were sent to the contract by mistake back to their sender. -*/ -contract TokenHolder is ITokenHolder, Owned { - /** - @dev constructor - */ - function TokenHolder() { - } - - // validates an address - currently only checks that it isn't null - modifier validAddress(address _address) { - require(_address != 0x0); - _; - } - - // verifies that the address is different than this contract address - modifier notThis(address _address) { - require(_address != address(this)); - _; - } - - /** - @dev withdraws tokens held by the contract and sends them to an account - can only be called by the owner - - @param _token ERC20 token contract address - @param _to account to receive the new amount - @param _amount amount to withdraw - */ - function withdrawTokens(IERC20Token _token, address _to, uint256 _amount) - public - ownerOnly - validAddress(_token) - validAddress(_to) - notThis(_to) - { - assert(_token.transfer(_to, _amount)); - } -} - -/* - Smart Token v0.2 - - 'Owned' is specified here for readability reasons -*/ -contract SmartToken is ISmartToken, ERC20Token, Owned, TokenHolder { - string public version = '0.2'; - - bool public transfersEnabled = true; // true if transfer/transferFrom are enabled, false if not - - // triggered when a smart token is deployed - the _token address is defined for forward compatibility, in case we want to trigger the event from a factory - event NewSmartToken(address _token); - // triggered when the total supply is increased - event Issuance(uint256 _amount); - // triggered when the total supply is decreased - event Destruction(uint256 _amount); - - /** - @dev constructor - - @param _name token name - @param _symbol token short symbol, 1-6 characters - @param _decimals for display purposes only - */ - function SmartToken(string _name, string _symbol, uint8 _decimals) - ERC20Token(_name, _symbol, _decimals) - { - require(bytes(_symbol).length <= 6); // validate input - NewSmartToken(address(this)); - } - - // allows execution only when transfers aren't disabled - modifier transfersAllowed { - assert(transfersEnabled); - _; - } - - /** - @dev disables/enables transfers - can only be called by the contract owner - - @param _disable true to disable transfers, false to enable them - */ - function disableTransfers(bool _disable) public ownerOnly { - transfersEnabled = !_disable; - } - - /** - @dev increases the token supply and sends the new tokens to an account - can only be called by the contract owner - - @param _to account to receive the new amount - @param _amount amount to increase the supply by - */ - function issue(address _to, uint256 _amount) - public - ownerOnly - validAddress(_to) - notThis(_to) - { - totalSupply = safeAdd(totalSupply, _amount); - balanceOf[_to] = safeAdd(balanceOf[_to], _amount); - - Issuance(_amount); - Transfer(this, _to, _amount); - } - - /** - @dev removes tokens from an account and decreases the token supply - can only be called by the contract owner - - @param _from account to remove the amount from - @param _amount amount to decrease the supply by - */ - function destroy(address _from, uint256 _amount) - public - ownerOnly - { - balanceOf[_from] = safeSub(balanceOf[_from], _amount); - totalSupply = safeSub(totalSupply, _amount); - - Transfer(_from, this, _amount); - Destruction(_amount); - } - - // ERC20 standard method overrides with some extra functionality - - /** - @dev send coins - throws on any error rather then return a false flag to minimize user errors - note that when transferring to the smart token's address, the coins are actually destroyed - - @param _to target address - @param _value transfer amount - - @return true if the transfer was successful, false if it wasn't - */ - function transfer(address _to, uint256 _value) public transfersAllowed returns (bool success) { - assert(super.transfer(_to, _value)); - - // transferring to the contract address destroys tokens - if (_to == address(this)) { - balanceOf[_to] -= _value; - totalSupply -= _value; - Destruction(_value); - } - - return true; - } - - /** - @dev an account/contract attempts to get the coins - throws on any error rather then return a false flag to minimize user errors - note that when transferring to the smart token's address, the coins are actually destroyed - - @param _from source address - @param _to target address - @param _value transfer amount - - @return true if the transfer was successful, false if it wasn't - */ - function transferFrom(address _from, address _to, uint256 _value) public transfersAllowed returns (bool success) { - assert(super.transferFrom(_from, _to, _value)); - - // transferring to the contract address destroys tokens - if (_to == address(this)) { - balanceOf[_to] -= _value; - totalSupply -= _value; - Destruction(_value); - } - - return true; - } -} - -/// @title Ownable -/// @dev The Ownable contract has an owner address, and provides basic authorization control functions, this simplifies -/// & the implementation of "user permissions". -contract Ownable { - address public owner; - address public newOwnerCandidate; - - event OwnershipRequested(address indexed _by, address indexed _to); - event OwnershipTransferred(address indexed _from, address indexed _to); - - /// @dev The Ownable constructor sets the original `owner` of the contract to the sender account. - function Ownable() { - owner = msg.sender; - } - - /// @dev Throws if called by any account other than the owner. - modifier onlyOwner() { - if (msg.sender != owner) { - throw; - } - - _; - } - - /// @dev Proposes to transfer control of the contract to a newOwnerCandidate. - /// @param _newOwnerCandidate address The address to transfer ownership to. - function transferOwnership(address _newOwnerCandidate) onlyOwner { - require(_newOwnerCandidate != address(0)); - - newOwnerCandidate = _newOwnerCandidate; - - OwnershipRequested(msg.sender, newOwnerCandidate); - } - - /// @dev Accept ownership transfer. This method needs to be called by the perviously proposed owner. - function acceptOwnership() { - if (msg.sender == newOwnerCandidate) { - owner = newOwnerCandidate; - newOwnerCandidate = address(0); - - OwnershipTransferred(owner, newOwnerCandidate); - } - } -} - -/// @title Math operations with safety checks -library SaferMath { - function mul(uint256 a, uint256 b) internal returns (uint256) { - uint256 c = a * b; - assert(a == 0 || c / a == b); - return c; - } - - function div(uint256 a, uint256 b) internal returns (uint256) { - // assert(b > 0); // Solidity automatically throws when dividing by 0 - uint256 c = a / b; - // assert(a == b * c + a % b); // There is no case in which this doesn't hold - return c; - } - - function sub(uint256 a, uint256 b) internal returns (uint256) { - assert(b <= a); - return a - b; - } - - function add(uint256 a, uint256 b) internal returns (uint256) { - uint256 c = a + b; - assert(c >= a); - return c; - } - - function max64(uint64 a, uint64 b) internal constant returns (uint64) { - return a >= b ? a : b; - } - - function min64(uint64 a, uint64 b) internal constant returns (uint64) { - return a < b ? a : b; - } - - function max256(uint256 a, uint256 b) internal constant returns (uint256) { - return a >= b ? a : b; - } - - function min256(uint256 a, uint256 b) internal constant returns (uint256) { - return a < b ? a : b; - } -} - - -/// @title Stox Smart Token -contract StoxSmartToken is SmartToken { - function StoxSmartToken() SmartToken('Stox', 'STX', 18) { - disableTransfers(true); - } -} - - -/// @title Vesting trustee -contract Trustee is Ownable { - using SaferMath for uint256; - - // The address of the STX ERC20 token. - StoxSmartToken public stox; - - struct Grant { - uint256 value; - uint256 start; - uint256 cliff; - uint256 end; - uint256 transferred; - bool revokable; - } - - // Grants holder. - mapping (address => Grant) public grants; - - // Total tokens available for vesting. - uint256 public totalVesting; - - event NewGrant(address indexed _from, address indexed _to, uint256 _value); - event UnlockGrant(address indexed _holder, uint256 _value); - event RevokeGrant(address indexed _holder, uint256 _refund); - - /// @dev Constructor that initializes the address of the StoxSmartToken contract. - /// @param _stox StoxSmartToken The address of the previously deployed StoxSmartToken smart contract. - function Trustee(StoxSmartToken _stox) { - require(_stox != address(0)); - - stox = _stox; - } - - /// @dev Grant tokens to a specified address. - /// @param _to address The address to grant tokens to. - /// @param _value uint256 The amount of tokens to be granted. - /// @param _start uint256 The beginning of the vesting period. - /// @param _cliff uint256 Duration of the cliff period. - /// @param _end uint256 The end of the vesting period. - /// @param _revokable bool Whether the grant is revokable or not. - function grant(address _to, uint256 _value, uint256 _start, uint256 _cliff, uint256 _end, bool _revokable) - public onlyOwner { - require(_to != address(0)); - require(_value > 0); - - // Make sure that a single address can be granted tokens only once. - require(grants[_to].value == 0); - - // Check for date inconsistencies that may cause unexpected behavior. - require(_start <= _cliff && _cliff <= _end); - - // Check that this grant doesn't exceed the total amount of tokens currently available for vesting. - require(totalVesting.add(_value) <= stox.balanceOf(address(this))); - - // Assign a new grant. - grants[_to] = Grant({ - value: _value, - start: _start, - cliff: _cliff, - end: _end, - transferred: 0, - revokable: _revokable - }); - - // Tokens granted, reduce the total amount available for vesting. - totalVesting = totalVesting.add(_value); - - NewGrant(msg.sender, _to, _value); - } - - /// @dev Revoke the grant of tokens of a specifed address. - /// @param _holder The address which will have its tokens revoked. - function revoke(address _holder) public onlyOwner { - Grant grant = grants[_holder]; - - require(grant.revokable); - - // Send the remaining STX back to the owner. - uint256 refund = grant.value.sub(grant.transferred); - - // Remove the grant. - delete grants[_holder]; - - totalVesting = totalVesting.sub(refund); - stox.transfer(msg.sender, refund); - - RevokeGrant(_holder, refund); - } - - /// @dev Calculate the total amount of vested tokens of a holder at a given time. - /// @param _holder address The address of the holder. - /// @param _time uint256 The specific time. - /// @return a uint256 representing a holder's total amount of vested tokens. - function vestedTokens(address _holder, uint256 _time) public constant returns (uint256) { - Grant grant = grants[_holder]; - if (grant.value == 0) { - return 0; - } - - return calculateVestedTokens(grant, _time); - } - - /// @dev Calculate amount of vested tokens at a specifc time. - /// @param _grant Grant The vesting grant. - /// @param _time uint256 The time to be checked - /// @return An uint256 representing the amount of vested tokens of a specific grant. - /// | _/-------- vestedTokens rect - /// | _/ - /// | _/ - /// | _/ - /// | _/ - /// | / - /// | .| - /// | . | - /// | . | - /// | . | - /// | . | - /// | . | - /// +===+===========+---------+----------> time - /// Start Cliff End - function calculateVestedTokens(Grant _grant, uint256 _time) private constant returns (uint256) { - // If we're before the cliff, then nothing is vested. - if (_time < _grant.cliff) { - return 0; - } - - // If we're after the end of the vesting period - everything is vested; - if (_time >= _grant.end) { - return _grant.value; - } - - // Interpolate all vested tokens: vestedTokens = tokens/// (time - start) / (end - start) - return _grant.value.mul(_time.sub(_grant.start)).div(_grant.end.sub(_grant.start)); - } - - /// @dev Unlock vested tokens and transfer them to their holder. - /// @return a uint256 representing the amount of vested tokens transferred to their holder. - function unlockVestedTokens() public { - Grant grant = grants[msg.sender]; - require(grant.value != 0); - - // Get the total amount of vested tokens, acccording to grant. - uint256 vested = calculateVestedTokens(grant, now); - if (vested == 0) { - return; - } - - // Make sure the holder doesn't transfer more than what he already has. - uint256 transferable = vested.sub(grant.transferred); - if (transferable == 0) { - return; - } - - grant.transferred = grant.transferred.add(transferable); - totalVesting = totalVesting.sub(transferable); - stox.transfer(msg.sender, transferable); - - UnlockGrant(msg.sender, transferable); - } -} - - -/// @title Stox Smart Token sale -contract StoxSmartTokenSale is Ownable { - using SaferMath for uint256; - - uint256 public constant DURATION = 14 days; - - bool public isFinalized = false; - bool public isDistributed = false; - - // The address of the STX ERC20 token. - StoxSmartToken public stox; - - // The address of the token allocation trustee; - Trustee public trustee; - - uint256 public startTime = 0; - uint256 public endTime = 0; - address public fundingRecipient; - - uint256 public tokensSold = 0; - - // TODO: update to the correct values. - uint256 public constant ETH_CAP = 148000; - uint256 public constant EXCHANGE_RATE = 200; // 200 STX for ETH - uint256 public constant TOKEN_SALE_CAP = ETH_CAP * EXCHANGE_RATE * 10 ** 18; - - event TokensIssued(address indexed _to, uint256 _tokens); - - /// @dev Throws if called when not during sale. - modifier onlyDuringSale() { - if (tokensSold >= TOKEN_SALE_CAP || now < startTime || now >= endTime) { - throw; - } - - _; - } - - /// @dev Throws if called before sale ends. - modifier onlyAfterSale() { - if (!(tokensSold >= TOKEN_SALE_CAP || now >= endTime)) { - throw; - } - - _; - } - - /// @dev Constructor that initializes the sale conditions. - /// @param _fundingRecipient address The address of the funding recipient. - /// @param _startTime uint256 The start time of the token sale. - function StoxSmartTokenSale(address _stox, address _fundingRecipient, uint256 _startTime) { - require(_stox != address(0)); - require(_fundingRecipient != address(0)); - require(_startTime > now); - - stox = StoxSmartToken(_stox); - - fundingRecipient = _fundingRecipient; - startTime = _startTime; - endTime = startTime + DURATION; - } - - /// @dev Distributed tokens to the partners who have participated during the pre-sale. - function distributePartnerTokens() external onlyOwner { - require(!isDistributed); - - assert(tokensSold == 0); - assert(stox.totalSupply() == 0); - - // Distribute strategic tokens to partners. Please note, that this address doesn't represent a single entity or - // person and will be only used to distribute tokens to 30~ partners. - // - // Please expect to see token transfers from this address in the first 24 hours after the token sale ends. - issueTokens(0x9065260ef6830f6372F1Bde408DeC57Fe3150530, 14800000 * 10 ** 18); - - isDistributed = true; - } - - /// @dev Finalizes the token sale event. - function finalize() external onlyAfterSale { - if (isFinalized) { - throw; - } - - // Grant vesting grants. - // - // TODO: use real addresses. - trustee = new Trustee(stox); - - // Since only 50% of the tokens will be sold, we will automatically issue the same amount of sold STX to the - // trustee. - uint256 unsoldTokens = tokensSold; - - // Issue 55% of the remaining tokens (== 27.5%) go to strategic parternships. - uint256 strategicPartnershipTokens = unsoldTokens.mul(55).div(100); - - // Note: we will substract the bonus tokens from this grant, since they were already issued for the pre-sale - // strategic partners and should've been taken from this allocation. - stox.issue(0xbC14105ccDdeAadB96Ba8dCE18b40C45b6bACf58, strategicPartnershipTokens); - - // Issue the remaining tokens as vesting grants: - stox.issue(trustee, unsoldTokens.sub(strategicPartnershipTokens)); - - // 25% of the remaining tokens (== 12.5%) go to Invest.com, at uniform 12 months vesting schedule. - trustee.grant(0xb54c6a870d4aD65e23d471Fb7941aD271D323f5E, unsoldTokens.mul(25).div(100), now, now, - now.add(1 years), true); - - // 20% of the remaining tokens (== 10%) go to Stox team, at uniform 24 months vesting schedule. - trustee.grant(0x4eB4Cd1D125d9d281709Ff38d65b99a6927b46c1, unsoldTokens.mul(20).div(100), now, now, - now.add(2 years), true); - - // Re-enable transfers after the token sale. - stox.disableTransfers(false); - - isFinalized = true; - } - - /// @dev Create and sell tokens to the caller. - /// @param _recipient address The address of the recipient. - function create(address _recipient) public payable onlyDuringSale { - require(_recipient != address(0)); - require(msg.value > 0); - - assert(isDistributed); - - uint256 tokens = SaferMath.min256(msg.value.mul(EXCHANGE_RATE), TOKEN_SALE_CAP.sub(tokensSold)); - uint256 contribution = tokens.div(EXCHANGE_RATE); - - issueTokens(_recipient, tokens); - - // Transfer the funds to the funding recipient. - fundingRecipient.transfer(contribution); - - // Refund the msg.sender, in the case that not all of its ETH was used. This can happen only when selling the - // last chunk of STX. - uint256 refund = msg.value.sub(contribution); - if (refund > 0) { - msg.sender.transfer(refund); - } - } - - /// @dev Issues tokens for the recipient. - /// @param _recipient address The address of the recipient. - /// @param _tokens uint256 The amount of tokens to issue. - function issueTokens(address _recipient, uint256 _tokens) private { - // Update total sold tokens. - tokensSold = tokensSold.add(_tokens); - - stox.issue(_recipient, _tokens); - - TokensIssued(_recipient, _tokens); - } - - /// @dev Fallback function that will delegate the request to create. - function () external payable onlyDuringSale { - create(msg.sender); - } - - /// @dev Proposes to transfer control of the StoxSmartToken contract to a new owner. - /// @param _newOwnerCandidate address The address to transfer ownership to. - /// - /// Note that: - /// 1. The new owner will need to call StoxSmartToken's acceptOwnership directly in order to accept the ownership. - /// 2. Calling this method during the token sale will prevent the token sale to continue, since only the owner of - /// the StoxSmartToken contract can issue new tokens. - function transferSmartTokenOwnership(address _newOwnerCandidate) external onlyOwner { - stox.transferOwnership(_newOwnerCandidate); - } - - /// @dev Accepts new ownership on behalf of the StoxSmartToken contract. This can be used, by the token sale - /// contract itself to claim back ownership of the StoxSmartToken contract. - function acceptSmartTokenOwnership() external onlyOwner { - stox.acceptOwnership(); - } - - /// @dev Proposes to transfer control of the Trustee contract to a new owner. - /// @param _newOwnerCandidate address The address to transfer ownership to. - /// - /// Note that: - /// 1. The new owner will need to call Trustee's acceptOwnership directly in order to accept the ownership. - /// 2. Calling this method during the token sale won't be possible, as the Trustee is only created after its - /// finalization. - function transferTrusteeOwnership(address _newOwnerCandidate) external onlyOwner { - trustee.transferOwnership(_newOwnerCandidate); - } - - /// @dev Accepts new ownership on behalf of the Trustee contract. This can be used, by the token sale - /// contract itself to claim back ownership of the Trustee contract. - function acceptTrusteeOwnership() external onlyOwner { - trustee.acceptOwnership(); - } -} \ No newline at end of file diff --git a/slither/tools/slither_format/tests/real_world/0x0235fe624e044a05eed7a43e16e3083bc8a4287a_OriginalToken.sol b/slither/tools/slither_format/tests/real_world/0x0235fe624e044a05eed7a43e16e3083bc8a4287a_OriginalToken.sol deleted file mode 100644 index 2f7283ff0..000000000 --- a/slither/tools/slither_format/tests/real_world/0x0235fe624e044a05eed7a43e16e3083bc8a4287a_OriginalToken.sol +++ /dev/null @@ -1,241 +0,0 @@ -pragma solidity ^0.4.17; - -contract Cofounded { - mapping (address => uint) public cofounderIndices; - address[] public cofounders; - - - /// @dev restrict execution to one of original cofounder addresses - modifier restricted () { - uint cofounderIndex = cofounderIndices[msg.sender]; - require(msg.sender == cofounders[cofounderIndex]); - _; - } - - /// @notice creates the Cofounded contract instance - /// @dev adds up to cofounders. - /// also adds the deployment address as a cofounder - function Cofounded (address[] contractCofounders) public { - cofounders.push(msg.sender); - - for (uint8 x = 0; x < contractCofounders.length; x++) { - address cofounder = contractCofounders[x]; - - bool isValidUniqueCofounder = - cofounder != address(0) && - cofounder != msg.sender && - cofounderIndices[cofounder] == 0; - - - // NOTE: solidity as of 0.4.20 does not have an - // undefined or null-like value - // thusly mappings return the default value of the value type - // for an unregistered key value - // an address which doesn't exist will return 0 - // which is actually the index of the address of the first - // cofounder - if (isValidUniqueCofounder) { - uint256 cofounderIndex = cofounders.push(cofounder) - 1; - cofounderIndices[cofounder] = cofounderIndex; - } - } - } - - /// @dev get count of cofounders - function getCofounderCount () public constant returns (uint256) { - return cofounders.length; - } - - /// @dev get list of cofounders - function getCofounders () public constant returns (address[]) { - return cofounders; - } -} - -interface ERC20 { - - // Required methods - function transfer (address to, uint256 value) public returns (bool success); - function transferFrom (address from, address to, uint256 value) public returns (bool success); - function approve (address spender, uint256 value) public returns (bool success); - function allowance (address owner, address spender) public constant returns (uint256 remaining); - function balanceOf (address owner) public constant returns (uint256 balance); - // Events - event Transfer (address indexed from, address indexed to, uint256 value); - event Approval (address indexed owner, address indexed spender, uint256 value); -} - - -/// @title Interface for contracts conforming to ERC-165: Pseudo-Introspection, or standard interface detection -/// @author Mish Ochu -interface ERC165 { - /// @dev true iff the interface is supported - function supportsInterface(bytes4 interfaceID) external constant returns (bool); -} -contract InterfaceSignatureConstants { - bytes4 constant InterfaceSignature_ERC165 = - bytes4(keccak256('supportsInterface(bytes4)')); - - bytes4 constant InterfaceSignature_ERC20 = - bytes4(keccak256('totalSupply()')) ^ - bytes4(keccak256('balanceOf(address)')) ^ - bytes4(keccak256('transfer(address,uint256)')) ^ - bytes4(keccak256('transferFrom(address,address,uint256)')) ^ - bytes4(keccak256('approve(address,uint256)')) ^ - bytes4(keccak256('allowance(address,address)')); - - bytes4 constant InterfaceSignature_ERC20_PlusOptions = - bytes4(keccak256('name()')) ^ - bytes4(keccak256('symbol()')) ^ - bytes4(keccak256('decimals()')) ^ - bytes4(keccak256('totalSupply()')) ^ - bytes4(keccak256('balanceOf(address)')) ^ - bytes4(keccak256('transfer(address,uint256)')) ^ - bytes4(keccak256('transferFrom(address,address,uint256)')) ^ - bytes4(keccak256('approve(address,uint256)')) ^ - bytes4(keccak256('allowance(address,address)')); -} - -/// @title an original cofounder based ERC-20 compliant token -/// @author Mish Ochu -/// @dev Ref: https://github.com/ethereum/EIPs/issues/721 -//http://solidity.readthedocs.io/en/develop/contracts.html#arguments-for-base-constructors -contract OriginalToken is Cofounded, ERC20, ERC165, InterfaceSignatureConstants { - bool private hasExecutedCofounderDistribution; - struct Allowance { - uint256 amount; - bool hasBeenPartiallyWithdrawn; - } - - //***** Apparently Optional *****/ - /// @dev returns the name of the token - string public constant name = 'Original Crypto Coin'; - /// @dev returns the symbol of the token (e.g. 'OCC') - string public constant symbol = 'OCC'; - /// @dev returns the number of decimals the tokens use - uint8 public constant decimals = 18; - //**********/ - - /// @dev returns the total token supply - /// @note implemented as a state variable with an automatic (compiler provided) getter - /// instead of a constant (view/readonly) function. - uint256 public totalSupply = 100000000000000000000000000000; - - mapping (address => uint256) public balances; - // TODO: determine if the gas cost for handling the race condition - // (outlined here: https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729) - // is cheaper this way (or this way: https://github.com/Giveth/minime/blob/master/contracts/MiniMeToken.sol#L221-L225) - mapping (address => mapping (address => Allowance)) public allowances; - - /// @dev creates the token - /// NOTE passes tokenCofounders to base contract - /// see Cofounded - function OriginalToken (address[] tokenCofounders, - uint256 cofounderDistribution) Cofounded(tokenCofounders) public { - - if (hasExecutedCofounderDistribution || - cofounderDistribution == 0 || - totalSupply < cofounderDistribution) revert(); - - hasExecutedCofounderDistribution = true; - uint256 initialSupply = totalSupply; - - // divvy up initial token supply accross cofounders - // TODO: ensure each cofounder gets an equal base distribution - - for (uint8 x = 0; x < cofounders.length; x++) { - address cofounder = cofounders[x]; - - initialSupply -= cofounderDistribution; - // there should be some left over for the airdrop campaign - // otherwise don't create this contract - if (initialSupply < cofounderDistribution) revert(); - balances[cofounder] = cofounderDistribution; - } - - balances[msg.sender] += initialSupply; - } - - function transfer (address to, uint256 value) public returns (bool) { - return transferBalance (msg.sender, to, value); - } - - function transferFrom (address from, address to, uint256 value) public returns (bool success) { - Allowance storage allowance = allowances[from][msg.sender]; - if (allowance.amount < value) revert(); - - allowance.hasBeenPartiallyWithdrawn = true; - allowance.amount -= value; - - if (allowance.amount == 0) { - delete allowances[from][msg.sender]; - } - - return transferBalance(from, to, value); - } - - event ApprovalDenied (address indexed owner, address indexed spender); - - // TODO: test with an unintialized Allowance struct - function approve (address spender, uint256 value) public returns (bool success) { - Allowance storage allowance = allowances[msg.sender][spender]; - - if (value == 0) { - delete allowances[msg.sender][spender]; - Approval(msg.sender, spender, value); - return true; - } - - if (allowance.hasBeenPartiallyWithdrawn) { - delete allowances[msg.sender][spender]; - ApprovalDenied(msg.sender, spender); - return false; - } else { - allowance.amount = value; - Approval(msg.sender, spender, value); - } - - return true; - } - - // TODO: compare gas cost estimations between this and https://github.com/ConsenSys/Tokens/blob/master/contracts/eip20/EIP20.sol#L39-L45 - function transferBalance (address from, address to, uint256 value) private returns (bool) { - // don't burn these tokens - if (to == address(0) || from == to) revert(); - // match spec and emit events on 0 value - if (value == 0) { - Transfer(msg.sender, to, value); - return true; - } - - uint256 senderBalance = balances[from]; - uint256 receiverBalance = balances[to]; - if (senderBalance < value) revert(); - senderBalance -= value; - receiverBalance += value; - // overflow check (altough one could use https://github.com/OpenZeppelin/zeppelin-solidity/blob/master/contracts/math/SafeMath.sol) - if (receiverBalance < value) revert(); - - balances[from] = senderBalance; - balances[to] = receiverBalance; - - Transfer(from, to, value); - return true; - } - - - // TODO: test with an unintialized Allowance struct - function allowance (address owner, address spender) public constant returns (uint256 remaining) { - return allowances[owner][spender].amount; - } - - function balanceOf (address owner) public constant returns (uint256 balance) { - return balances[owner]; - } - - function supportsInterface (bytes4 interfaceID) external constant returns (bool) { - return ((interfaceID == InterfaceSignature_ERC165) || - (interfaceID == InterfaceSignature_ERC20) || - (interfaceID == InterfaceSignature_ERC20_PlusOptions)); - } -} \ No newline at end of file diff --git a/slither/tools/slither_format/tests/real_world/0x05cf67329a262818e67c080e9d511a34d36152c0_MultiSigWallet.sol b/slither/tools/slither_format/tests/real_world/0x05cf67329a262818e67c080e9d511a34d36152c0_MultiSigWallet.sol deleted file mode 100644 index 53465564c..000000000 --- a/slither/tools/slither_format/tests/real_world/0x05cf67329a262818e67c080e9d511a34d36152c0_MultiSigWallet.sol +++ /dev/null @@ -1,367 +0,0 @@ -pragma solidity ^0.4.15; - -// From https://github.com/ConsenSys/MultiSigWallet/blob/master/contracts/solidity/MultiSigWallet.sol @ e3240481928e9d2b57517bd192394172e31da487 - -/// @title Multisignature wallet - Allows multiple parties to agree on transactions before execution. -/// @author Stefan George - <[email protected]> -contract MultiSigWallet { - - uint constant public MAX_OWNER_COUNT = 5; - - event Confirmation(address indexed sender, uint indexed transactionId); - event Revocation(address indexed sender, uint indexed transactionId); - event Submission(uint indexed transactionId); - event Execution(uint indexed transactionId); - event ExecutionFailure(uint indexed transactionId); - event Deposit(address indexed sender, uint value); - event OwnerAddition(address indexed owner); - event OwnerRemoval(address indexed owner); - event RequirementChange(uint required); - - mapping (uint => Transaction) public transactions; - mapping (uint => mapping (address => bool)) public confirmations; - mapping (address => bool) public isOwner; - address[] public owners; - uint public required; - uint public transactionCount; - - struct Transaction { - address destination; - uint value; - bytes data; - bool executed; - } - - modifier onlyWallet() { - if (msg.sender != address(this)) - throw; - _; - } - - modifier ownerDoesNotExist(address owner) { - if (isOwner[owner]) - throw; - _; - } - - modifier ownerExists(address owner) { - if (!isOwner[owner]) - throw; - _; - } - - modifier transactionExists(uint transactionId) { - if (transactions[transactionId].destination == 0) - throw; - _; - } - - modifier confirmed(uint transactionId, address owner) { - if (!confirmations[transactionId][owner]) - throw; - _; - } - - modifier notConfirmed(uint transactionId, address owner) { - if (confirmations[transactionId][owner]) - throw; - _; - } - - modifier notExecuted(uint transactionId) { - if (transactions[transactionId].executed) - throw; - _; - } - - modifier notNull(address _address) { - if (_address == 0) - throw; - _; - } - - modifier validRequirement(uint ownerCount, uint _required) { - if ( ownerCount > MAX_OWNER_COUNT - || _required > ownerCount - || _required == 0 - || ownerCount == 0) - throw; - _; - } - - /// @dev Fallback function allows to deposit ether. - function() - payable - { - if (msg.value > 0) - Deposit(msg.sender, msg.value); - } - - /* - * Public functions - */ - /// @dev Contract constructor sets initial owners and required number of confirmations. - function MultiSigWallet() - public - { - address owner1 = address(0x5117afB03e83d180D0059a1Ad733F954220D2734); - address owner2 = address(0x4F9049886d8087c7549224383075ffbb3dF2b7a0); - address owner3 = address(0x4E63227fcFF602b3Fa9e6F4e86b33194f04236B1); - owners.push(address(owner1)); - owners.push(address(owner2)); - owners.push(address(owner3)); - isOwner[owner1] = true; - isOwner[owner2] = true; - isOwner[owner3] = true; - required = 3; - } - - /// @dev Allows to add a new owner. Transaction has to be sent by wallet. - /// @param owner Address of new owner. - function addOwner(address owner) - public - onlyWallet - ownerDoesNotExist(owner) - notNull(owner) - validRequirement(owners.length + 1, required) - { - isOwner[owner] = true; - owners.push(owner); - OwnerAddition(owner); - } - - /// @dev Allows to remove an owner. Transaction has to be sent by wallet. - /// @param owner Address of owner. - function removeOwner(address owner) - public - onlyWallet - ownerExists(owner) - { - isOwner[owner] = false; - for (uint i=0; i owners.length) - changeRequirement(owners.length); - OwnerRemoval(owner); - } - - /// @dev Allows to replace an owner with a new owner. Transaction has to be sent by wallet. - /// @param owner Address of owner to be replaced. - /// @param owner Address of new owner. - function replaceOwner(address owner, address newOwner) - public - onlyWallet - ownerExists(owner) - ownerDoesNotExist(newOwner) - { - for (uint i=0; i 0); // Solidity automatically throws when dividing by 0 - uint256 c = a / b; - // assert(a == b * c + a % b); // There is no case in which this doesn't hold - return c; - } - - function sub(uint256 a, uint256 b) internal pure returns (uint256) { - assert(b <= a); - return a - b; - } - - function add(uint256 a, uint256 b) internal pure returns (uint256) { - uint256 c = a + b; - assert(c >= a); - return c; - } -} - - -/** - * @title Basic token - * @dev Basic version of StandardToken, with no allowances. - */ -contract BasicToken is ERC20Basic { - using SafeMath for uint256; - - mapping(address => uint256) balances; - - /** - * @dev transfer token for a specified address - * @param _to The address to transfer to. - * @param _value The amount to be transferred. - */ - function transfer(address _to, uint256 _value) public returns (bool) { - require(_to != address(0)); - require(_value <= balances[msg.sender]); - - // SafeMath.sub will throw if there is not enough balance. - balances[msg.sender] = balances[msg.sender].sub(_value); - balances[_to] = balances[_to].add(_value); - Transfer(msg.sender, _to, _value); - return true; - } - - /** - * @dev Gets the balance of the specified address. - * @param _owner The address to query the the balance of. - * @return An uint256 representing the amount owned by the passed address. - */ - function balanceOf(address _owner) public view returns (uint256 balance) { - return balances[_owner]; - } - -} - -/** - * @title Standard ERC20 token - * - * @dev Implementation of the basic standard token. - * @dev https://github.com/ethereum/EIPs/issues/20 - * @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol - */ -contract StandardToken is ERC20, BasicToken { - - mapping (address => mapping (address => uint256)) internal allowed; - - - /** - * @dev Transfer tokens from one address to another - * @param _from address The address which you want to send tokens from - * @param _to address The address which you want to transfer to - * @param _value uint256 the amount of tokens to be transferred - */ - function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { - require(_to != address(0)); - require(_value <= balances[_from]); - require(_value <= allowed[_from][msg.sender]); - - balances[_from] = balances[_from].sub(_value); - balances[_to] = balances[_to].add(_value); - allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); - Transfer(_from, _to, _value); - return true; - } - - /** - * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender. - * - * Beware that changing an allowance with this method brings the risk that someone may use both the old - * and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this - * race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards: - * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 - * @param _spender The address which will spend the funds. - * @param _value The amount of tokens to be spent. - */ - function approve(address _spender, uint256 _value) public returns (bool) { - allowed[msg.sender][_spender] = _value; - Approval(msg.sender, _spender, _value); - return true; - } - - /** - * @dev Function to check the amount of tokens that an owner allowed to a spender. - * @param _owner address The address which owns the funds. - * @param _spender address The address which will spend the funds. - * @return A uint256 specifying the amount of tokens still available for the spender. - */ - function allowance(address _owner, address _spender) public view returns (uint256) { - return allowed[_owner][_spender]; - } - - /** - * approve should be called when allowed[_spender] == 0. To increment - * allowed value is better to use this function to avoid 2 calls (and wait until - * the first transaction is mined) - * From MonolithDAO Token.sol - */ - function increaseApproval(address _spender, uint _addedValue) public returns (bool) { - allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue); - Approval(msg.sender, _spender, allowed[msg.sender][_spender]); - return true; - } - - function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) { - uint oldValue = allowed[msg.sender][_spender]; - if (_subtractedValue > oldValue) { - allowed[msg.sender][_spender] = 0; - } else { - allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue); - } - Approval(msg.sender, _spender, allowed[msg.sender][_spender]); - return true; - } - -} - -/** - * @title Ownable - * @dev The Ownable contract has an owner address, and provides basic authorization control - * functions, this simplifies the implementation of "user permissions". - */ -contract Ownable { - address public owner; - - - event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); - - - /** - * @dev The Ownable constructor sets the original `owner` of the contract to the sender - * account. - */ - function Ownable() public { - owner = msg.sender; - } - - - /** - * @dev Throws if called by any account other than the owner. - */ - modifier onlyOwner() { - require(msg.sender == owner); - _; - } - - - /** - * @dev Allows the current owner to transfer control of the contract to a newOwner. - * @param newOwner The address to transfer ownership to. - */ - function transferOwnership(address newOwner) public onlyOwner { - require(newOwner != address(0)); - OwnershipTransferred(owner, newOwner); - owner = newOwner; - } - -} - -/** - * @title Pausable - * @dev Base contract which allows children to implement an emergency stop mechanism. - */ -contract Pausable is Ownable { - event PausePublic(bool newState); - event PauseOwnerAdmin(bool newState); - - bool public pausedPublic = true; - bool public pausedOwnerAdmin = false; - - address public admin; - - /** - * @dev Modifier to make a function callable based on pause states. - */ - modifier whenNotPaused() { - if(pausedPublic) { - if(!pausedOwnerAdmin) { - require(msg.sender == admin || msg.sender == owner); - } else { - revert(); - } - } - _; - } - - /** - * @dev called by the owner to set new pause flags - * pausedPublic can't be false while pausedOwnerAdmin is true - */ - function pause(bool newPausedPublic, bool newPausedOwnerAdmin) onlyOwner public { - require(!(newPausedPublic == false && newPausedOwnerAdmin == true)); - - pausedPublic = newPausedPublic; - pausedOwnerAdmin = newPausedOwnerAdmin; - - PausePublic(newPausedPublic); - PauseOwnerAdmin(newPausedOwnerAdmin); - } -} - -contract PausableToken is StandardToken, Pausable { - - function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) { - return super.transfer(_to, _value); - } - - function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) { - return super.transferFrom(_from, _to, _value); - } - - function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) { - return super.approve(_spender, _value); - } - - function increaseApproval(address _spender, uint _addedValue) public whenNotPaused returns (bool success) { - return super.increaseApproval(_spender, _addedValue); - } - - function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused returns (bool success) { - return super.decreaseApproval(_spender, _subtractedValue); - } -} - - -contract ZilliqaToken is PausableToken { - string public constant name = "Zilliqa"; - string public constant symbol = "ZIL"; - uint8 public constant decimals = 12; - - modifier validDestination( address to ) - { - require(to != address(0x0)); - require(to != address(this)); - _; - } - - function ZilliqaToken( address _admin, uint _totalTokenAmount ) - { - // assign the admin account - admin = _admin; - - // assign the total tokens to zilliqa - totalSupply = _totalTokenAmount; - balances[msg.sender] = _totalTokenAmount; - Transfer(address(0x0), msg.sender, _totalTokenAmount); - } - - function transfer(address _to, uint _value) validDestination(_to) returns (bool) - { - return super.transfer(_to, _value); - } - - function transferFrom(address _from, address _to, uint _value) validDestination(_to) returns (bool) - { - return super.transferFrom(_from, _to, _value); - } - - event Burn(address indexed _burner, uint _value); - - function burn(uint _value) returns (bool) - { - balances[msg.sender] = balances[msg.sender].sub(_value); - totalSupply = totalSupply.sub(_value); - Burn(msg.sender, _value); - Transfer(msg.sender, address(0x0), _value); - return true; - } - - // save some gas by making only one contract call - function burnFrom(address _from, uint256 _value) returns (bool) - { - assert( transferFrom( _from, msg.sender, _value ) ); - return burn(_value); - } - - function emergencyERC20Drain( ERC20 token, uint amount ) onlyOwner { - // owner can drain tokens that are sent here by mistake - token.transfer( owner, amount ); - } - - event AdminTransferred(address indexed previousAdmin, address indexed newAdmin); - - function changeAdmin(address newAdmin) onlyOwner { - // owner can re-assign the admin - AdminTransferred(admin, newAdmin); - admin = newAdmin; - } -} \ No newline at end of file diff --git a/slither/tools/slither_format/tests/real_world/0x06012c8cf97bead5deae237070f9587f8e7a266d_KittyCore.sol b/slither/tools/slither_format/tests/real_world/0x06012c8cf97bead5deae237070f9587f8e7a266d_KittyCore.sol deleted file mode 100644 index 99868cfac..000000000 --- a/slither/tools/slither_format/tests/real_world/0x06012c8cf97bead5deae237070f9587f8e7a266d_KittyCore.sol +++ /dev/null @@ -1,2009 +0,0 @@ -pragma solidity ^0.4.11; - - -/** - * @title Ownable - * @dev The Ownable contract has an owner address, and provides basic authorization control - * functions, this simplifies the implementation of "user permissions". - */ -contract Ownable { - address public owner; - - - /** - * @dev The Ownable constructor sets the original `owner` of the contract to the sender - * account. - */ - function Ownable() { - owner = msg.sender; - } - - - /** - * @dev Throws if called by any account other than the owner. - */ - modifier onlyOwner() { - require(msg.sender == owner); - _; - } - - - /** - * @dev Allows the current owner to transfer control of the contract to a newOwner. - * @param newOwner The address to transfer ownership to. - */ - function transferOwnership(address newOwner) onlyOwner { - if (newOwner != address(0)) { - owner = newOwner; - } - } - -} - - - -/// @title Interface for contracts conforming to ERC-721: Non-Fungible Tokens -/// @author Dieter Shirley <[email protected]> (https://github.com/dete) -contract ERC721 { - // Required methods - function totalSupply() public view returns (uint256 total); - function balanceOf(address _owner) public view returns (uint256 balance); - function ownerOf(uint256 _tokenId) external view returns (address owner); - function approve(address _to, uint256 _tokenId) external; - function transfer(address _to, uint256 _tokenId) external; - function transferFrom(address _from, address _to, uint256 _tokenId) external; - - // Events - event Transfer(address from, address to, uint256 tokenId); - event Approval(address owner, address approved, uint256 tokenId); - - // Optional - // function name() public view returns (string name); - // function symbol() public view returns (string symbol); - // function tokensOfOwner(address _owner) external view returns (uint256[] tokenIds); - // function tokenMetadata(uint256 _tokenId, string _preferredTransport) public view returns (string infoUrl); - - // ERC-165 Compatibility (https://github.com/ethereum/EIPs/issues/165) - function supportsInterface(bytes4 _interfaceID) external view returns (bool); -} - - -// // Auction wrapper functions - - -// Auction wrapper functions - - - - - - - -/// @title SEKRETOOOO -contract GeneScienceInterface { - /// @dev simply a boolean to indicate this is the contract we expect to be - function isGeneScience() public pure returns (bool); - - /// @dev given genes of kitten 1 & 2, return a genetic combination - may have a random factor - /// @param genes1 genes of mom - /// @param genes2 genes of sire - /// @return the genes that are supposed to be passed down the child - function mixGenes(uint256 genes1, uint256 genes2, uint256 targetBlock) public returns (uint256); -} - - - - - - - -/// @title A facet of KittyCore that manages special access privileges. -/// @author Axiom Zen (https://www.axiomzen.co) -/// @dev See the KittyCore contract documentation to understand how the various contract facets are arranged. -contract KittyAccessControl { - // This facet controls access control for CryptoKitties. There are four roles managed here: - // - // - The CEO: The CEO can reassign other roles and change the addresses of our dependent smart - // contracts. It is also the only role that can unpause the smart contract. It is initially - // set to the address that created the smart contract in the KittyCore constructor. - // - // - The CFO: The CFO can withdraw funds from KittyCore and its auction contracts. - // - // - The COO: The COO can release gen0 kitties to auction, and mint promo cats. - // - // It should be noted that these roles are distinct without overlap in their access abilities, the - // abilities listed for each role above are exhaustive. In particular, while the CEO can assign any - // address to any role, the CEO address itself doesn't have the ability to act in those roles. This - // restriction is intentional so that we aren't tempted to use the CEO address frequently out of - // convenience. The less we use an address, the less likely it is that we somehow compromise the - // account. - - /// @dev Emited when contract is upgraded - See README.md for updgrade plan - event ContractUpgrade(address newContract); - - // The addresses of the accounts (or contracts) that can execute actions within each roles. - address public ceoAddress; - address public cfoAddress; - address public cooAddress; - - // @dev Keeps track whether the contract is paused. When that is true, most actions are blocked - bool public paused = false; - - /// @dev Access modifier for CEO-only functionality - modifier onlyCEO() { - require(msg.sender == ceoAddress); - _; - } - - /// @dev Access modifier for CFO-only functionality - modifier onlyCFO() { - require(msg.sender == cfoAddress); - _; - } - - /// @dev Access modifier for COO-only functionality - modifier onlyCOO() { - require(msg.sender == cooAddress); - _; - } - - modifier onlyCLevel() { - require( - msg.sender == cooAddress || - msg.sender == ceoAddress || - msg.sender == cfoAddress - ); - _; - } - - /// @dev Assigns a new address to act as the CEO. Only available to the current CEO. - /// @param _newCEO The address of the new CEO - function setCEO(address _newCEO) external onlyCEO { - require(_newCEO != address(0)); - - ceoAddress = _newCEO; - } - - /// @dev Assigns a new address to act as the CFO. Only available to the current CEO. - /// @param _newCFO The address of the new CFO - function setCFO(address _newCFO) external onlyCEO { - require(_newCFO != address(0)); - - cfoAddress = _newCFO; - } - - /// @dev Assigns a new address to act as the COO. Only available to the current CEO. - /// @param _newCOO The address of the new COO - function setCOO(address _newCOO) external onlyCEO { - require(_newCOO != address(0)); - - cooAddress = _newCOO; - } - - /*** Pausable functionality adapted from OpenZeppelin ***/ - - /// @dev Modifier to allow actions only when the contract IS NOT paused - modifier whenNotPaused() { - require(!paused); - _; - } - - /// @dev Modifier to allow actions only when the contract IS paused - modifier whenPaused { - require(paused); - _; - } - - /// @dev Called by any "C-level" role to pause the contract. Used only when - /// a bug or exploit is detected and we need to limit damage. - function pause() external onlyCLevel whenNotPaused { - paused = true; - } - - /// @dev Unpauses the smart contract. Can only be called by the CEO, since - /// one reason we may pause the contract is when CFO or COO accounts are - /// compromised. - /// @notice This is public rather than external so it can be called by - /// derived contracts. - function unpause() public onlyCEO whenPaused { - // can't unpause if contract was upgraded - paused = false; - } -} - - - - -/// @title Base contract for CryptoKitties. Holds all common structs, events and base variables. -/// @author Axiom Zen (https://www.axiomzen.co) -/// @dev See the KittyCore contract documentation to understand how the various contract facets are arranged. -contract KittyBase is KittyAccessControl { - /*** EVENTS ***/ - - /// @dev The Birth event is fired whenever a new kitten comes into existence. This obviously - /// includes any time a cat is created through the giveBirth method, but it is also called - /// when a new gen0 cat is created. - event Birth(address owner, uint256 kittyId, uint256 matronId, uint256 sireId, uint256 genes); - - /// @dev Transfer event as defined in current draft of ERC721. Emitted every time a kitten - /// ownership is assigned, including births. - event Transfer(address from, address to, uint256 tokenId); - - /*** DATA TYPES ***/ - - /// @dev The main Kitty struct. Every cat in CryptoKitties is represented by a copy - /// of this structure, so great care was taken to ensure that it fits neatly into - /// exactly two 256-bit words. Note that the order of the members in this structure - /// is important because of the byte-packing rules used by Ethereum. - /// Ref: http://solidity.readthedocs.io/en/develop/miscellaneous.html - struct Kitty { - // The Kitty's genetic code is packed into these 256-bits, the format is - // sooper-sekret! A cat's genes never change. - uint256 genes; - - // The timestamp from the block when this cat came into existence. - uint64 birthTime; - - // The minimum timestamp after which this cat can engage in breeding - // activities again. This same timestamp is used for the pregnancy - // timer (for matrons) as well as the siring cooldown. - uint64 cooldownEndBlock; - - // The ID of the parents of this kitty, set to 0 for gen0 cats. - // Note that using 32-bit unsigned integers limits us to a "mere" - // 4 billion cats. This number might seem small until you realize - // that Ethereum currently has a limit of about 500 million - // transactions per year! So, this definitely won't be a problem - // for several years (even as Ethereum learns to scale). - uint32 matronId; - uint32 sireId; - - // Set to the ID of the sire cat for matrons that are pregnant, - // zero otherwise. A non-zero value here is how we know a cat - // is pregnant. Used to retrieve the genetic material for the new - // kitten when the birth transpires. - uint32 siringWithId; - - // Set to the index in the cooldown array (see below) that represents - // the current cooldown duration for this Kitty. This starts at zero - // for gen0 cats, and is initialized to floor(generation/2) for others. - // Incremented by one for each successful breeding action, regardless - // of whether this cat is acting as matron or sire. - uint16 cooldownIndex; - - // The "generation number" of this cat. Cats minted by the CK contract - // for sale are called "gen0" and have a generation number of 0. The - // generation number of all other cats is the larger of the two generation - // numbers of their parents, plus one. - // (i.e. max(matron.generation, sire.generation) + 1) - uint16 generation; - } - - /*** CONSTANTS ***/ - - /// @dev A lookup table indicating the cooldown duration after any successful - /// breeding action, called "pregnancy time" for matrons and "siring cooldown" - /// for sires. Designed such that the cooldown roughly doubles each time a cat - /// is bred, encouraging owners not to just keep breeding the same cat over - /// and over again. Caps out at one week (a cat can breed an unbounded number - /// of times, and the maximum cooldown is always seven days). - uint32[14] public cooldowns = [ - uint32(1 minutes), - uint32(2 minutes), - uint32(5 minutes), - uint32(10 minutes), - uint32(30 minutes), - uint32(1 hours), - uint32(2 hours), - uint32(4 hours), - uint32(8 hours), - uint32(16 hours), - uint32(1 days), - uint32(2 days), - uint32(4 days), - uint32(7 days) - ]; - - // An approximation of currently how many seconds are in between blocks. - uint256 public secondsPerBlock = 15; - - /*** STORAGE ***/ - - /// @dev An array containing the Kitty struct for all Kitties in existence. The ID - /// of each cat is actually an index into this array. Note that ID 0 is a negacat, - /// the unKitty, the mythical beast that is the parent of all gen0 cats. A bizarre - /// creature that is both matron and sire... to itself! Has an invalid genetic code. - /// In other words, cat ID 0 is invalid... ;-) - Kitty[] kitties; - - /// @dev A mapping from cat IDs to the address that owns them. All cats have - /// some valid owner address, even gen0 cats are created with a non-zero owner. - mapping (uint256 => address) public kittyIndexToOwner; - - // @dev A mapping from owner address to count of tokens that address owns. - // Used internally inside balanceOf() to resolve ownership count. - mapping (address => uint256) ownershipTokenCount; - - /// @dev A mapping from KittyIDs to an address that has been approved to call - /// transferFrom(). Each Kitty can only have one approved address for transfer - /// at any time. A zero value means no approval is outstanding. - mapping (uint256 => address) public kittyIndexToApproved; - - /// @dev A mapping from KittyIDs to an address that has been approved to use - /// this Kitty for siring via breedWith(). Each Kitty can only have one approved - /// address for siring at any time. A zero value means no approval is outstanding. - mapping (uint256 => address) public sireAllowedToAddress; - - /// @dev The address of the ClockAuction contract that handles sales of Kitties. This - /// same contract handles both peer-to-peer sales as well as the gen0 sales which are - /// initiated every 15 minutes. - SaleClockAuction public saleAuction; - - /// @dev The address of a custom ClockAuction subclassed contract that handles siring - /// auctions. Needs to be separate from saleAuction because the actions taken on success - /// after a sales and siring auction are quite different. - SiringClockAuction public siringAuction; - - /// @dev Assigns ownership of a specific Kitty to an address. - function _transfer(address _from, address _to, uint256 _tokenId) internal { - // Since the number of kittens is capped to 2^32 we can't overflow this - ownershipTokenCount[_to]++; - // transfer ownership - kittyIndexToOwner[_tokenId] = _to; - // When creating new kittens _from is 0x0, but we can't account that address. - if (_from != address(0)) { - ownershipTokenCount[_from]--; - // once the kitten is transferred also clear sire allowances - delete sireAllowedToAddress[_tokenId]; - // clear any previously approved ownership exchange - delete kittyIndexToApproved[_tokenId]; - } - // Emit the transfer event. - Transfer(_from, _to, _tokenId); - } - - /// @dev An internal method that creates a new kitty and stores it. This - /// method doesn't do any checking and should only be called when the - /// input data is known to be valid. Will generate both a Birth event - /// and a Transfer event. - /// @param _matronId The kitty ID of the matron of this cat (zero for gen0) - /// @param _sireId The kitty ID of the sire of this cat (zero for gen0) - /// @param _generation The generation number of this cat, must be computed by caller. - /// @param _genes The kitty's genetic code. - /// @param _owner The inital owner of this cat, must be non-zero (except for the unKitty, ID 0) - function _createKitty( - uint256 _matronId, - uint256 _sireId, - uint256 _generation, - uint256 _genes, - address _owner - ) - internal - returns (uint) - { - // These requires are not strictly necessary, our calling code should make - // sure that these conditions are never broken. However! _createKitty() is already - // an expensive call (for storage), and it doesn't hurt to be especially careful - // to ensure our data structures are always valid. - require(_matronId == uint256(uint32(_matronId))); - require(_sireId == uint256(uint32(_sireId))); - require(_generation == uint256(uint16(_generation))); - - // New kitty starts with the same cooldown as parent gen/2 - uint16 cooldownIndex = uint16(_generation / 2); - if (cooldownIndex > 13) { - cooldownIndex = 13; - } - - Kitty memory _kitty = Kitty({ - genes: _genes, - birthTime: uint64(now), - cooldownEndBlock: 0, - matronId: uint32(_matronId), - sireId: uint32(_sireId), - siringWithId: 0, - cooldownIndex: cooldownIndex, - generation: uint16(_generation) - }); - uint256 newKittenId = kitties.push(_kitty) - 1; - - // It's probably never going to happen, 4 billion cats is A LOT, but - // let's just be 100% sure we never let this happen. - require(newKittenId == uint256(uint32(newKittenId))); - - // emit the birth event - Birth( - _owner, - newKittenId, - uint256(_kitty.matronId), - uint256(_kitty.sireId), - _kitty.genes - ); - - // This will assign ownership, and also emit the Transfer event as - // per ERC721 draft - _transfer(0, _owner, newKittenId); - - return newKittenId; - } - - // Any C-level can fix how many seconds per blocks are currently observed. - function setSecondsPerBlock(uint256 secs) external onlyCLevel { - require(secs < cooldowns[0]); - secondsPerBlock = secs; - } -} - - - - - -/// @title The external contract that is responsible for generating metadata for the kitties, -/// it has one function that will return the data as bytes. -contract ERC721Metadata { - /// @dev Given a token Id, returns a byte array that is supposed to be converted into string. - function getMetadata(uint256 _tokenId, string) public view returns (bytes32[4] buffer, uint256 count) { - if (_tokenId == 1) { - buffer[0] = "Hello World! :D"; - count = 15; - } else if (_tokenId == 2) { - buffer[0] = "I would definitely choose a medi"; - buffer[1] = "um length string."; - count = 49; - } else if (_tokenId == 3) { - buffer[0] = "Lorem ipsum dolor sit amet, mi e"; - buffer[1] = "st accumsan dapibus augue lorem,"; - buffer[2] = " tristique vestibulum id, libero"; - buffer[3] = " suscipit varius sapien aliquam."; - count = 128; - } - } -} - - -/// @title The facet of the CryptoKitties core contract that manages ownership, ERC-721 (draft) compliant. -/// @author Axiom Zen (https://www.axiomzen.co) -/// @dev Ref: https://github.com/ethereum/EIPs/issues/721 -/// See the KittyCore contract documentation to understand how the various contract facets are arranged. -contract KittyOwnership is KittyBase, ERC721 { - - /// @notice Name and symbol of the non fungible token, as defined in ERC721. - string public constant name = "CryptoKitties"; - string public constant symbol = "CK"; - - // The contract that will return kitty metadata - ERC721Metadata public erc721Metadata; - - bytes4 constant InterfaceSignature_ERC165 = - bytes4(keccak256('supportsInterface(bytes4)')); - - bytes4 constant InterfaceSignature_ERC721 = - bytes4(keccak256('name()')) ^ - bytes4(keccak256('symbol()')) ^ - bytes4(keccak256('totalSupply()')) ^ - bytes4(keccak256('balanceOf(address)')) ^ - bytes4(keccak256('ownerOf(uint256)')) ^ - bytes4(keccak256('approve(address,uint256)')) ^ - bytes4(keccak256('transfer(address,uint256)')) ^ - bytes4(keccak256('transferFrom(address,address,uint256)')) ^ - bytes4(keccak256('tokensOfOwner(address)')) ^ - bytes4(keccak256('tokenMetadata(uint256,string)')); - - /// @notice Introspection interface as per ERC-165 (https://github.com/ethereum/EIPs/issues/165). - /// Returns true for any standardized interfaces implemented by this contract. We implement - /// ERC-165 (obviously!) and ERC-721. - function supportsInterface(bytes4 _interfaceID) external view returns (bool) - { - // DEBUG ONLY - //require((InterfaceSignature_ERC165 == 0x01ffc9a7) && (InterfaceSignature_ERC721 == 0x9a20483d)); - - return ((_interfaceID == InterfaceSignature_ERC165) || (_interfaceID == InterfaceSignature_ERC721)); - } - - /// @dev Set the address of the sibling contract that tracks metadata. - /// CEO only. - function setMetadataAddress(address _contractAddress) public onlyCEO { - erc721Metadata = ERC721Metadata(_contractAddress); - } - - // Internal utility functions: These functions all assume that their input arguments - // are valid. We leave it to public methods to sanitize their inputs and follow - // the required logic. - - /// @dev Checks if a given address is the current owner of a particular Kitty. - /// @param _claimant the address we are validating against. - /// @param _tokenId kitten id, only valid when > 0 - function _owns(address _claimant, uint256 _tokenId) internal view returns (bool) { - return kittyIndexToOwner[_tokenId] == _claimant; - } - - /// @dev Checks if a given address currently has transferApproval for a particular Kitty. - /// @param _claimant the address we are confirming kitten is approved for. - /// @param _tokenId kitten id, only valid when > 0 - function _approvedFor(address _claimant, uint256 _tokenId) internal view returns (bool) { - return kittyIndexToApproved[_tokenId] == _claimant; - } - - /// @dev Marks an address as being approved for transferFrom(), overwriting any previous - /// approval. Setting _approved to address(0) clears all transfer approval. - /// NOTE: _approve() does NOT send the Approval event. This is intentional because - /// _approve() and transferFrom() are used together for putting Kitties on auction, and - /// there is no value in spamming the log with Approval events in that case. - function _approve(uint256 _tokenId, address _approved) internal { - kittyIndexToApproved[_tokenId] = _approved; - } - - /// @notice Returns the number of Kitties owned by a specific address. - /// @param _owner The owner address to check. - /// @dev Required for ERC-721 compliance - function balanceOf(address _owner) public view returns (uint256 count) { - return ownershipTokenCount[_owner]; - } - - /// @notice Transfers a Kitty to another address. If transferring to a smart - /// contract be VERY CAREFUL to ensure that it is aware of ERC-721 (or - /// CryptoKitties specifically) or your Kitty may be lost forever. Seriously. - /// @param _to The address of the recipient, can be a user or contract. - /// @param _tokenId The ID of the Kitty to transfer. - /// @dev Required for ERC-721 compliance. - function transfer( - address _to, - uint256 _tokenId - ) - external - whenNotPaused - { - // Safety check to prevent against an unexpected 0x0 default. - require(_to != address(0)); - // Disallow transfers to this contract to prevent accidental misuse. - // The contract should never own any kitties (except very briefly - // after a gen0 cat is created and before it goes on auction). - require(_to != address(this)); - // Disallow transfers to the auction contracts to prevent accidental - // misuse. Auction contracts should only take ownership of kitties - // through the allow + transferFrom flow. - require(_to != address(saleAuction)); - require(_to != address(siringAuction)); - - // You can only send your own cat. - require(_owns(msg.sender, _tokenId)); - - // Reassign ownership, clear pending approvals, emit Transfer event. - _transfer(msg.sender, _to, _tokenId); - } - - /// @notice Grant another address the right to transfer a specific Kitty via - /// transferFrom(). This is the preferred flow for transfering NFTs to contracts. - /// @param _to The address to be granted transfer approval. Pass address(0) to - /// clear all approvals. - /// @param _tokenId The ID of the Kitty that can be transferred if this call succeeds. - /// @dev Required for ERC-721 compliance. - function approve( - address _to, - uint256 _tokenId - ) - external - whenNotPaused - { - // Only an owner can grant transfer approval. - require(_owns(msg.sender, _tokenId)); - - // Register the approval (replacing any previous approval). - _approve(_tokenId, _to); - - // Emit approval event. - Approval(msg.sender, _to, _tokenId); - } - - /// @notice Transfer a Kitty owned by another address, for which the calling address - /// has previously been granted transfer approval by the owner. - /// @param _from The address that owns the Kitty to be transfered. - /// @param _to The address that should take ownership of the Kitty. Can be any address, - /// including the caller. - /// @param _tokenId The ID of the Kitty to be transferred. - /// @dev Required for ERC-721 compliance. - function transferFrom( - address _from, - address _to, - uint256 _tokenId - ) - external - whenNotPaused - { - // Safety check to prevent against an unexpected 0x0 default. - require(_to != address(0)); - // Disallow transfers to this contract to prevent accidental misuse. - // The contract should never own any kitties (except very briefly - // after a gen0 cat is created and before it goes on auction). - require(_to != address(this)); - // Check for approval and valid ownership - require(_approvedFor(msg.sender, _tokenId)); - require(_owns(_from, _tokenId)); - - // Reassign ownership (also clears pending approvals and emits Transfer event). - _transfer(_from, _to, _tokenId); - } - - /// @notice Returns the total number of Kitties currently in existence. - /// @dev Required for ERC-721 compliance. - function totalSupply() public view returns (uint) { - return kitties.length - 1; - } - - /// @notice Returns the address currently assigned ownership of a given Kitty. - /// @dev Required for ERC-721 compliance. - function ownerOf(uint256 _tokenId) - external - view - returns (address owner) - { - owner = kittyIndexToOwner[_tokenId]; - - require(owner != address(0)); - } - - /// @notice Returns a list of all Kitty IDs assigned to an address. - /// @param _owner The owner whose Kitties we are interested in. - /// @dev This method MUST NEVER be called by smart contract code. First, it's fairly - /// expensive (it walks the entire Kitty array looking for cats belonging to owner), - /// but it also returns a dynamic array, which is only supported for web3 calls, and - /// not contract-to-contract calls. - function tokensOfOwner(address _owner) external view returns(uint256[] ownerTokens) { - uint256 tokenCount = balanceOf(_owner); - - if (tokenCount == 0) { - // Return an empty array - return new uint256[](0); - } else { - uint256[] memory result = new uint256[](tokenCount); - uint256 totalCats = totalSupply(); - uint256 resultIndex = 0; - - // We count on the fact that all cats have IDs starting at 1 and increasing - // sequentially up to the totalCat count. - uint256 catId; - - for (catId = 1; catId <= totalCats; catId++) { - if (kittyIndexToOwner[catId] == _owner) { - result[resultIndex] = catId; - resultIndex++; - } - } - - return result; - } - } - - /// @dev Adapted from memcpy() by @arachnid (Nick Johnson <[email protected]>) - /// This method is licenced under the Apache License. - /// Ref: https://github.com/Arachnid/solidity-stringutils/blob/2f6ca9accb48ae14c66f1437ec50ed19a0616f78/strings.sol - function _memcpy(uint _dest, uint _src, uint _len) private view { - // Copy word-length chunks while possible - for(; _len >= 32; _len -= 32) { - assembly { - mstore(_dest, mload(_src)) - } - _dest += 32; - _src += 32; - } - - // Copy remaining bytes - uint256 mask = 256 ** (32 - _len) - 1; - assembly { - let srcpart := and(mload(_src), not(mask)) - let destpart := and(mload(_dest), mask) - mstore(_dest, or(destpart, srcpart)) - } - } - - /// @dev Adapted from toString(slice) by @arachnid (Nick Johnson <[email protected]>) - /// This method is licenced under the Apache License. - /// Ref: https://github.com/Arachnid/solidity-stringutils/blob/2f6ca9accb48ae14c66f1437ec50ed19a0616f78/strings.sol - function _toString(bytes32[4] _rawBytes, uint256 _stringLength) private view returns (string) { - var outputString = new string(_stringLength); - uint256 outputPtr; - uint256 bytesPtr; - - assembly { - outputPtr := add(outputString, 32) - bytesPtr := _rawBytes - } - - _memcpy(outputPtr, bytesPtr, _stringLength); - - return outputString; - } - - /// @notice Returns a URI pointing to a metadata package for this token conforming to - /// ERC-721 (https://github.com/ethereum/EIPs/issues/721) - /// @param _tokenId The ID number of the Kitty whose metadata should be returned. - function tokenMetadata(uint256 _tokenId, string _preferredTransport) external view returns (string infoUrl) { - require(erc721Metadata != address(0)); - bytes32[4] memory buffer; - uint256 count; - (buffer, count) = erc721Metadata.getMetadata(_tokenId, _preferredTransport); - - return _toString(buffer, count); - } -} - - - -/// @title A facet of KittyCore that manages Kitty siring, gestation, and birth. -/// @author Axiom Zen (https://www.axiomzen.co) -/// @dev See the KittyCore contract documentation to understand how the various contract facets are arranged. -contract KittyBreeding is KittyOwnership { - - /// @dev The Pregnant event is fired when two cats successfully breed and the pregnancy - /// timer begins for the matron. - event Pregnant(address owner, uint256 matronId, uint256 sireId, uint256 cooldownEndBlock); - - /// @notice The minimum payment required to use breedWithAuto(). This fee goes towards - /// the gas cost paid by whatever calls giveBirth(), and can be dynamically updated by - /// the COO role as the gas price changes. - uint256 public autoBirthFee = 2 finney; - - // Keeps track of number of pregnant kitties. - uint256 public pregnantKitties; - - /// @dev The address of the sibling contract that is used to implement the sooper-sekret - /// genetic combination algorithm. - GeneScienceInterface public geneScience; - - /// @dev Update the address of the genetic contract, can only be called by the CEO. - /// @param _address An address of a GeneScience contract instance to be used from this point forward. - function setGeneScienceAddress(address _address) external onlyCEO { - GeneScienceInterface candidateContract = GeneScienceInterface(_address); - - // NOTE: verify that a contract is what we expect - https://github.com/Lunyr/crowdsale-contracts/blob/cfadd15986c30521d8ba7d5b6f57b4fefcc7ac38/contracts/LunyrToken.sol#L117 - require(candidateContract.isGeneScience()); - - // Set the new contract address - geneScience = candidateContract; - } - - /// @dev Checks that a given kitten is able to breed. Requires that the - /// current cooldown is finished (for sires) and also checks that there is - /// no pending pregnancy. - function _isReadyToBreed(Kitty _kit) internal view returns (bool) { - // In addition to checking the cooldownEndBlock, we also need to check to see if - // the cat has a pending birth; there can be some period of time between the end - // of the pregnacy timer and the birth event. - return (_kit.siringWithId == 0) && (_kit.cooldownEndBlock <= uint64(block.number)); - } - - /// @dev Check if a sire has authorized breeding with this matron. True if both sire - /// and matron have the same owner, or if the sire has given siring permission to - /// the matron's owner (via approveSiring()). - function _isSiringPermitted(uint256 _sireId, uint256 _matronId) internal view returns (bool) { - address matronOwner = kittyIndexToOwner[_matronId]; - address sireOwner = kittyIndexToOwner[_sireId]; - - // Siring is okay if they have same owner, or if the matron's owner was given - // permission to breed with this sire. - return (matronOwner == sireOwner || sireAllowedToAddress[_sireId] == matronOwner); - } - - /// @dev Set the cooldownEndTime for the given Kitty, based on its current cooldownIndex. - /// Also increments the cooldownIndex (unless it has hit the cap). - /// @param _kitten A reference to the Kitty in storage which needs its timer started. - function _triggerCooldown(Kitty storage _kitten) internal { - // Compute an estimation of the cooldown time in blocks (based on current cooldownIndex). - _kitten.cooldownEndBlock = uint64((cooldowns[_kitten.cooldownIndex]/secondsPerBlock) + block.number); - - // Increment the breeding count, clamping it at 13, which is the length of the - // cooldowns array. We could check the array size dynamically, but hard-coding - // this as a constant saves gas. Yay, Solidity! - if (_kitten.cooldownIndex < 13) { - _kitten.cooldownIndex += 1; - } - } - - /// @notice Grants approval to another user to sire with one of your Kitties. - /// @param _addr The address that will be able to sire with your Kitty. Set to - /// address(0) to clear all siring approvals for this Kitty. - /// @param _sireId A Kitty that you own that _addr will now be able to sire with. - function approveSiring(address _addr, uint256 _sireId) - external - whenNotPaused - { - require(_owns(msg.sender, _sireId)); - sireAllowedToAddress[_sireId] = _addr; - } - - /// @dev Updates the minimum payment required for calling giveBirthAuto(). Can only - /// be called by the COO address. (This fee is used to offset the gas cost incurred - /// by the autobirth daemon). - function setAutoBirthFee(uint256 val) external onlyCOO { - autoBirthFee = val; - } - - /// @dev Checks to see if a given Kitty is pregnant and (if so) if the gestation - /// period has passed. - function _isReadyToGiveBirth(Kitty _matron) private view returns (bool) { - return (_matron.siringWithId != 0) && (_matron.cooldownEndBlock <= uint64(block.number)); - } - - /// @notice Checks that a given kitten is able to breed (i.e. it is not pregnant or - /// in the middle of a siring cooldown). - /// @param _kittyId reference the id of the kitten, any user can inquire about it - function isReadyToBreed(uint256 _kittyId) - public - view - returns (bool) - { - require(_kittyId > 0); - Kitty storage kit = kitties[_kittyId]; - return _isReadyToBreed(kit); - } - - /// @dev Checks whether a kitty is currently pregnant. - /// @param _kittyId reference the id of the kitten, any user can inquire about it - function isPregnant(uint256 _kittyId) - public - view - returns (bool) - { - require(_kittyId > 0); - // A kitty is pregnant if and only if this field is set - return kitties[_kittyId].siringWithId != 0; - } - - /// @dev Internal check to see if a given sire and matron are a valid mating pair. DOES NOT - /// check ownership permissions (that is up to the caller). - /// @param _matron A reference to the Kitty struct of the potential matron. - /// @param _matronId The matron's ID. - /// @param _sire A reference to the Kitty struct of the potential sire. - /// @param _sireId The sire's ID - function _isValidMatingPair( - Kitty storage _matron, - uint256 _matronId, - Kitty storage _sire, - uint256 _sireId - ) - private - view - returns(bool) - { - // A Kitty can't breed with itself! - if (_matronId == _sireId) { - return false; - } - - // Kitties can't breed with their parents. - if (_matron.matronId == _sireId || _matron.sireId == _sireId) { - return false; - } - if (_sire.matronId == _matronId || _sire.sireId == _matronId) { - return false; - } - - // We can short circuit the sibling check (below) if either cat is - // gen zero (has a matron ID of zero). - if (_sire.matronId == 0 || _matron.matronId == 0) { - return true; - } - - // Kitties can't breed with full or half siblings. - if (_sire.matronId == _matron.matronId || _sire.matronId == _matron.sireId) { - return false; - } - if (_sire.sireId == _matron.matronId || _sire.sireId == _matron.sireId) { - return false; - } - - // Everything seems cool! Let's get DTF. - return true; - } - - /// @dev Internal check to see if a given sire and matron are a valid mating pair for - /// breeding via auction (i.e. skips ownership and siring approval checks). - function _canBreedWithViaAuction(uint256 _matronId, uint256 _sireId) - internal - view - returns (bool) - { - Kitty storage matron = kitties[_matronId]; - Kitty storage sire = kitties[_sireId]; - return _isValidMatingPair(matron, _matronId, sire, _sireId); - } - - /// @notice Checks to see if two cats can breed together, including checks for - /// ownership and siring approvals. Does NOT check that both cats are ready for - /// breeding (i.e. breedWith could still fail until the cooldowns are finished). - /// TODO: Shouldn't this check pregnancy and cooldowns?!? - /// @param _matronId The ID of the proposed matron. - /// @param _sireId The ID of the proposed sire. - function canBreedWith(uint256 _matronId, uint256 _sireId) - external - view - returns(bool) - { - require(_matronId > 0); - require(_sireId > 0); - Kitty storage matron = kitties[_matronId]; - Kitty storage sire = kitties[_sireId]; - return _isValidMatingPair(matron, _matronId, sire, _sireId) && - _isSiringPermitted(_sireId, _matronId); - } - - /// @dev Internal utility function to initiate breeding, assumes that all breeding - /// requirements have been checked. - function _breedWith(uint256 _matronId, uint256 _sireId) internal { - // Grab a reference to the Kitties from storage. - Kitty storage sire = kitties[_sireId]; - Kitty storage matron = kitties[_matronId]; - - // Mark the matron as pregnant, keeping track of who the sire is. - matron.siringWithId = uint32(_sireId); - - // Trigger the cooldown for both parents. - _triggerCooldown(sire); - _triggerCooldown(matron); - - // Clear siring permission for both parents. This may not be strictly necessary - // but it's likely to avoid confusion! - delete sireAllowedToAddress[_matronId]; - delete sireAllowedToAddress[_sireId]; - - // Every time a kitty gets pregnant, counter is incremented. - pregnantKitties++; - - // Emit the pregnancy event. - Pregnant(kittyIndexToOwner[_matronId], _matronId, _sireId, matron.cooldownEndBlock); - } - - /// @notice Breed a Kitty you own (as matron) with a sire that you own, or for which you - /// have previously been given Siring approval. Will either make your cat pregnant, or will - /// fail entirely. Requires a pre-payment of the fee given out to the first caller of giveBirth() - /// @param _matronId The ID of the Kitty acting as matron (will end up pregnant if successful) - /// @param _sireId The ID of the Kitty acting as sire (will begin its siring cooldown if successful) - function breedWithAuto(uint256 _matronId, uint256 _sireId) - external - payable - whenNotPaused - { - // Checks for payment. - require(msg.value >= autoBirthFee); - - // Caller must own the matron. - require(_owns(msg.sender, _matronId)); - - // Neither sire nor matron are allowed to be on auction during a normal - // breeding operation, but we don't need to check that explicitly. - // For matron: The caller of this function can't be the owner of the matron - // because the owner of a Kitty on auction is the auction house, and the - // auction house will never call breedWith(). - // For sire: Similarly, a sire on auction will be owned by the auction house - // and the act of transferring ownership will have cleared any oustanding - // siring approval. - // Thus we don't need to spend gas explicitly checking to see if either cat - // is on auction. - - // Check that matron and sire are both owned by caller, or that the sire - // has given siring permission to caller (i.e. matron's owner). - // Will fail for _sireId = 0 - require(_isSiringPermitted(_sireId, _matronId)); - - // Grab a reference to the potential matron - Kitty storage matron = kitties[_matronId]; - - // Make sure matron isn't pregnant, or in the middle of a siring cooldown - require(_isReadyToBreed(matron)); - - // Grab a reference to the potential sire - Kitty storage sire = kitties[_sireId]; - - // Make sure sire isn't pregnant, or in the middle of a siring cooldown - require(_isReadyToBreed(sire)); - - // Test that these cats are a valid mating pair. - require(_isValidMatingPair( - matron, - _matronId, - sire, - _sireId - )); - - // All checks passed, kitty gets pregnant! - _breedWith(_matronId, _sireId); - } - - /// @notice Have a pregnant Kitty give birth! - /// @param _matronId A Kitty ready to give birth. - /// @return The Kitty ID of the new kitten. - /// @dev Looks at a given Kitty and, if pregnant and if the gestation period has passed, - /// combines the genes of the two parents to create a new kitten. The new Kitty is assigned - /// to the current owner of the matron. Upon successful completion, both the matron and the - /// new kitten will be ready to breed again. Note that anyone can call this function (if they - /// are willing to pay the gas!), but the new kitten always goes to the mother's owner. - function giveBirth(uint256 _matronId) - external - whenNotPaused - returns(uint256) - { - // Grab a reference to the matron in storage. - Kitty storage matron = kitties[_matronId]; - - // Check that the matron is a valid cat. - require(matron.birthTime != 0); - - // Check that the matron is pregnant, and that its time has come! - require(_isReadyToGiveBirth(matron)); - - // Grab a reference to the sire in storage. - uint256 sireId = matron.siringWithId; - Kitty storage sire = kitties[sireId]; - - // Determine the higher generation number of the two parents - uint16 parentGen = matron.generation; - if (sire.generation > matron.generation) { - parentGen = sire.generation; - } - - // Call the sooper-sekret gene mixing operation. - uint256 childGenes = geneScience.mixGenes(matron.genes, sire.genes, matron.cooldownEndBlock - 1); - - // Make the new kitten! - address owner = kittyIndexToOwner[_matronId]; - uint256 kittenId = _createKitty(_matronId, matron.siringWithId, parentGen + 1, childGenes, owner); - - // Clear the reference to sire from the matron (REQUIRED! Having siringWithId - // set is what marks a matron as being pregnant.) - delete matron.siringWithId; - - // Every time a kitty gives birth counter is decremented. - pregnantKitties--; - - // Send the balance fee to the person who made birth happen. - msg.sender.send(autoBirthFee); - - // return the new kitten's ID - return kittenId; - } -} - - - - - - - - - - -/// @title Auction Core -/// @dev Contains models, variables, and internal methods for the auction. -/// @notice We omit a fallback function to prevent accidental sends to this contract. -contract ClockAuctionBase { - - // Represents an auction on an NFT - struct Auction { - // Current owner of NFT - address seller; - // Price (in wei) at beginning of auction - uint128 startingPrice; - // Price (in wei) at end of auction - uint128 endingPrice; - // Duration (in seconds) of auction - uint64 duration; - // Time when auction started - // NOTE: 0 if this auction has been concluded - uint64 startedAt; - } - - // Reference to contract tracking NFT ownership - ERC721 public nonFungibleContract; - - // Cut owner takes on each auction, measured in basis points (1/100 of a percent). - // Values 0-10,000 map to 0%-100% - uint256 public ownerCut; - - // Map from token ID to their corresponding auction. - mapping (uint256 => Auction) tokenIdToAuction; - - event AuctionCreated(uint256 tokenId, uint256 startingPrice, uint256 endingPrice, uint256 duration); - event AuctionSuccessful(uint256 tokenId, uint256 totalPrice, address winner); - event AuctionCancelled(uint256 tokenId); - - /// @dev Returns true if the claimant owns the token. - /// @param _claimant - Address claiming to own the token. - /// @param _tokenId - ID of token whose ownership to verify. - function _owns(address _claimant, uint256 _tokenId) internal view returns (bool) { - return (nonFungibleContract.ownerOf(_tokenId) == _claimant); - } - - /// @dev Escrows the NFT, assigning ownership to this contract. - /// Throws if the escrow fails. - /// @param _owner - Current owner address of token to escrow. - /// @param _tokenId - ID of token whose approval to verify. - function _escrow(address _owner, uint256 _tokenId) internal { - // it will throw if transfer fails - nonFungibleContract.transferFrom(_owner, this, _tokenId); - } - - /// @dev Transfers an NFT owned by this contract to another address. - /// Returns true if the transfer succeeds. - /// @param _receiver - Address to transfer NFT to. - /// @param _tokenId - ID of token to transfer. - function _transfer(address _receiver, uint256 _tokenId) internal { - // it will throw if transfer fails - nonFungibleContract.transfer(_receiver, _tokenId); - } - - /// @dev Adds an auction to the list of open auctions. Also fires the - /// AuctionCreated event. - /// @param _tokenId The ID of the token to be put on auction. - /// @param _auction Auction to add. - function _addAuction(uint256 _tokenId, Auction _auction) internal { - // Require that all auctions have a duration of - // at least one minute. (Keeps our math from getting hairy!) - require(_auction.duration >= 1 minutes); - - tokenIdToAuction[_tokenId] = _auction; - - AuctionCreated( - uint256(_tokenId), - uint256(_auction.startingPrice), - uint256(_auction.endingPrice), - uint256(_auction.duration) - ); - } - - /// @dev Cancels an auction unconditionally. - function _cancelAuction(uint256 _tokenId, address _seller) internal { - _removeAuction(_tokenId); - _transfer(_seller, _tokenId); - AuctionCancelled(_tokenId); - } - - /// @dev Computes the price and transfers winnings. - /// Does NOT transfer ownership of token. - function _bid(uint256 _tokenId, uint256 _bidAmount) - internal - returns (uint256) - { - // Get a reference to the auction struct - Auction storage auction = tokenIdToAuction[_tokenId]; - - // Explicitly check that this auction is currently live. - // (Because of how Ethereum mappings work, we can't just count - // on the lookup above failing. An invalid _tokenId will just - // return an auction object that is all zeros.) - require(_isOnAuction(auction)); - - // Check that the bid is greater than or equal to the current price - uint256 price = _currentPrice(auction); - require(_bidAmount >= price); - - // Grab a reference to the seller before the auction struct - // gets deleted. - address seller = auction.seller; - - // The bid is good! Remove the auction before sending the fees - // to the sender so we can't have a reentrancy attack. - _removeAuction(_tokenId); - - // Transfer proceeds to seller (if there are any!) - if (price > 0) { - // Calculate the auctioneer's cut. - // (NOTE: _computeCut() is guaranteed to return a - // value <= price, so this subtraction can't go negative.) - uint256 auctioneerCut = _computeCut(price); - uint256 sellerProceeds = price - auctioneerCut; - - // NOTE: Doing a transfer() in the middle of a complex - // method like this is generally discouraged because of - // reentrancy attacks and DoS attacks if the seller is - // a contract with an invalid fallback function. We explicitly - // guard against reentrancy attacks by removing the auction - // before calling transfer(), and the only thing the seller - // can DoS is the sale of their own asset! (And if it's an - // accident, they can call cancelAuction(). ) - seller.transfer(sellerProceeds); - } - - // Calculate any excess funds included with the bid. If the excess - // is anything worth worrying about, transfer it back to bidder. - // NOTE: We checked above that the bid amount is greater than or - // equal to the price so this cannot underflow. - uint256 bidExcess = _bidAmount - price; - - // Return the funds. Similar to the previous transfer, this is - // not susceptible to a re-entry attack because the auction is - // removed before any transfers occur. - msg.sender.transfer(bidExcess); - - // Tell the world! - AuctionSuccessful(_tokenId, price, msg.sender); - - return price; - } - - /// @dev Removes an auction from the list of open auctions. - /// @param _tokenId - ID of NFT on auction. - function _removeAuction(uint256 _tokenId) internal { - delete tokenIdToAuction[_tokenId]; - } - - /// @dev Returns true if the NFT is on auction. - /// @param _auction - Auction to check. - function _isOnAuction(Auction storage _auction) internal view returns (bool) { - return (_auction.startedAt > 0); - } - - /// @dev Returns current price of an NFT on auction. Broken into two - /// functions (this one, that computes the duration from the auction - /// structure, and the other that does the price computation) so we - /// can easily test that the price computation works correctly. - function _currentPrice(Auction storage _auction) - internal - view - returns (uint256) - { - uint256 secondsPassed = 0; - - // A bit of insurance against negative values (or wraparound). - // Probably not necessary (since Ethereum guarnatees that the - // now variable doesn't ever go backwards). - if (now > _auction.startedAt) { - secondsPassed = now - _auction.startedAt; - } - - return _computeCurrentPrice( - _auction.startingPrice, - _auction.endingPrice, - _auction.duration, - secondsPassed - ); - } - - /// @dev Computes the current price of an auction. Factored out - /// from _currentPrice so we can run extensive unit tests. - /// When testing, make this function public and turn on - /// `Current price computation` test suite. - function _computeCurrentPrice( - uint256 _startingPrice, - uint256 _endingPrice, - uint256 _duration, - uint256 _secondsPassed - ) - internal - pure - returns (uint256) - { - // NOTE: We don't use SafeMath (or similar) in this function because - // all of our public functions carefully cap the maximum values for - // time (at 64-bits) and currency (at 128-bits). _duration is - // also known to be non-zero (see the require() statement in - // _addAuction()) - if (_secondsPassed >= _duration) { - // We've reached the end of the dynamic pricing portion - // of the auction, just return the end price. - return _endingPrice; - } else { - // Starting price can be higher than ending price (and often is!), so - // this delta can be negative. - int256 totalPriceChange = int256(_endingPrice) - int256(_startingPrice); - - // This multiplication can't overflow, _secondsPassed will easily fit within - // 64-bits, and totalPriceChange will easily fit within 128-bits, their product - // will always fit within 256-bits. - int256 currentPriceChange = totalPriceChange * int256(_secondsPassed) / int256(_duration); - - // currentPriceChange can be negative, but if so, will have a magnitude - // less that _startingPrice. Thus, this result will always end up positive. - int256 currentPrice = int256(_startingPrice) + currentPriceChange; - - return uint256(currentPrice); - } - } - - /// @dev Computes owner's cut of a sale. - /// @param _price - Sale price of NFT. - function _computeCut(uint256 _price) internal view returns (uint256) { - // NOTE: We don't use SafeMath (or similar) in this function because - // all of our entry functions carefully cap the maximum values for - // currency (at 128-bits), and ownerCut <= 10000 (see the require() - // statement in the ClockAuction constructor). The result of this - // function is always guaranteed to be <= _price. - return _price * ownerCut / 10000; - } - -} - - - - - - - -/** - * @title Pausable - * @dev Base contract which allows children to implement an emergency stop mechanism. - */ -contract Pausable is Ownable { - event Pause(); - event Unpause(); - - bool public paused = false; - - - /** - * @dev modifier to allow actions only when the contract IS paused - */ - modifier whenNotPaused() { - require(!paused); - _; - } - - /** - * @dev modifier to allow actions only when the contract IS NOT paused - */ - modifier whenPaused { - require(paused); - _; - } - - /** - * @dev called by the owner to pause, triggers stopped state - */ - function pause() onlyOwner whenNotPaused returns (bool) { - paused = true; - Pause(); - return true; - } - - /** - * @dev called by the owner to unpause, returns to normal state - */ - function unpause() onlyOwner whenPaused returns (bool) { - paused = false; - Unpause(); - return true; - } -} - - -/// @title Clock auction for non-fungible tokens. -/// @notice We omit a fallback function to prevent accidental sends to this contract. -contract ClockAuction is Pausable, ClockAuctionBase { - - /// @dev The ERC-165 interface signature for ERC-721. - /// Ref: https://github.com/ethereum/EIPs/issues/165 - /// Ref: https://github.com/ethereum/EIPs/issues/721 - bytes4 constant InterfaceSignature_ERC721 = bytes4(0x9a20483d); - - /// @dev Constructor creates a reference to the NFT ownership contract - /// and verifies the owner cut is in the valid range. - /// @param _nftAddress - address of a deployed contract implementing - /// the Nonfungible Interface. - /// @param _cut - percent cut the owner takes on each auction, must be - /// between 0-10,000. - function ClockAuction(address _nftAddress, uint256 _cut) public { - require(_cut <= 10000); - ownerCut = _cut; - - ERC721 candidateContract = ERC721(_nftAddress); - require(candidateContract.supportsInterface(InterfaceSignature_ERC721)); - nonFungibleContract = candidateContract; - } - - /// @dev Remove all Ether from the contract, which is the owner's cuts - /// as well as any Ether sent directly to the contract address. - /// Always transfers to the NFT contract, but can be called either by - /// the owner or the NFT contract. - function withdrawBalance() external { - address nftAddress = address(nonFungibleContract); - - require( - msg.sender == owner || - msg.sender == nftAddress - ); - // We are using this boolean method to make sure that even if one fails it will still work - bool res = nftAddress.send(this.balance); - } - - /// @dev Creates and begins a new auction. - /// @param _tokenId - ID of token to auction, sender must be owner. - /// @param _startingPrice - Price of item (in wei) at beginning of auction. - /// @param _endingPrice - Price of item (in wei) at end of auction. - /// @param _duration - Length of time to move between starting - /// price and ending price (in seconds). - /// @param _seller - Seller, if not the message sender - function createAuction( - uint256 _tokenId, - uint256 _startingPrice, - uint256 _endingPrice, - uint256 _duration, - address _seller - ) - external - whenNotPaused - { - // Sanity check that no inputs overflow how many bits we've allocated - // to store them in the auction struct. - require(_startingPrice == uint256(uint128(_startingPrice))); - require(_endingPrice == uint256(uint128(_endingPrice))); - require(_duration == uint256(uint64(_duration))); - - require(_owns(msg.sender, _tokenId)); - _escrow(msg.sender, _tokenId); - Auction memory auction = Auction( - _seller, - uint128(_startingPrice), - uint128(_endingPrice), - uint64(_duration), - uint64(now) - ); - _addAuction(_tokenId, auction); - } - - /// @dev Bids on an open auction, completing the auction and transferring - /// ownership of the NFT if enough Ether is supplied. - /// @param _tokenId - ID of token to bid on. - function bid(uint256 _tokenId) - external - payable - whenNotPaused - { - // _bid will throw if the bid or funds transfer fails - _bid(_tokenId, msg.value); - _transfer(msg.sender, _tokenId); - } - - /// @dev Cancels an auction that hasn't been won yet. - /// Returns the NFT to original owner. - /// @notice This is a state-modifying function that can - /// be called while the contract is paused. - /// @param _tokenId - ID of token on auction - function cancelAuction(uint256 _tokenId) - external - { - Auction storage auction = tokenIdToAuction[_tokenId]; - require(_isOnAuction(auction)); - address seller = auction.seller; - require(msg.sender == seller); - _cancelAuction(_tokenId, seller); - } - - /// @dev Cancels an auction when the contract is paused. - /// Only the owner may do this, and NFTs are returned to - /// the seller. This should only be used in emergencies. - /// @param _tokenId - ID of the NFT on auction to cancel. - function cancelAuctionWhenPaused(uint256 _tokenId) - whenPaused - onlyOwner - external - { - Auction storage auction = tokenIdToAuction[_tokenId]; - require(_isOnAuction(auction)); - _cancelAuction(_tokenId, auction.seller); - } - - /// @dev Returns auction info for an NFT on auction. - /// @param _tokenId - ID of NFT on auction. - function getAuction(uint256 _tokenId) - external - view - returns - ( - address seller, - uint256 startingPrice, - uint256 endingPrice, - uint256 duration, - uint256 startedAt - ) { - Auction storage auction = tokenIdToAuction[_tokenId]; - require(_isOnAuction(auction)); - return ( - auction.seller, - auction.startingPrice, - auction.endingPrice, - auction.duration, - auction.startedAt - ); - } - - /// @dev Returns the current price of an auction. - /// @param _tokenId - ID of the token price we are checking. - function getCurrentPrice(uint256 _tokenId) - external - view - returns (uint256) - { - Auction storage auction = tokenIdToAuction[_tokenId]; - require(_isOnAuction(auction)); - return _currentPrice(auction); - } - -} - - -/// @title Reverse auction modified for siring -/// @notice We omit a fallback function to prevent accidental sends to this contract. -contract SiringClockAuction is ClockAuction { - - // @dev Sanity check that allows us to ensure that we are pointing to the - // right auction in our setSiringAuctionAddress() call. - bool public isSiringClockAuction = true; - - // Delegate constructor - function SiringClockAuction(address _nftAddr, uint256 _cut) public - ClockAuction(_nftAddr, _cut) {} - - /// @dev Creates and begins a new auction. Since this function is wrapped, - /// require sender to be KittyCore contract. - /// @param _tokenId - ID of token to auction, sender must be owner. - /// @param _startingPrice - Price of item (in wei) at beginning of auction. - /// @param _endingPrice - Price of item (in wei) at end of auction. - /// @param _duration - Length of auction (in seconds). - /// @param _seller - Seller, if not the message sender - function createAuction( - uint256 _tokenId, - uint256 _startingPrice, - uint256 _endingPrice, - uint256 _duration, - address _seller - ) - external - { - // Sanity check that no inputs overflow how many bits we've allocated - // to store them in the auction struct. - require(_startingPrice == uint256(uint128(_startingPrice))); - require(_endingPrice == uint256(uint128(_endingPrice))); - require(_duration == uint256(uint64(_duration))); - - require(msg.sender == address(nonFungibleContract)); - _escrow(_seller, _tokenId); - Auction memory auction = Auction( - _seller, - uint128(_startingPrice), - uint128(_endingPrice), - uint64(_duration), - uint64(now) - ); - _addAuction(_tokenId, auction); - } - - /// @dev Places a bid for siring. Requires the sender - /// is the KittyCore contract because all bid methods - /// should be wrapped. Also returns the kitty to the - /// seller rather than the winner. - function bid(uint256 _tokenId) - external - payable - { - require(msg.sender == address(nonFungibleContract)); - address seller = tokenIdToAuction[_tokenId].seller; - // _bid checks that token ID is valid and will throw if bid fails - _bid(_tokenId, msg.value); - // We transfer the kitty back to the seller, the winner will get - // the offspring - _transfer(seller, _tokenId); - } - -} - - - - - -/// @title Clock auction modified for sale of kitties -/// @notice We omit a fallback function to prevent accidental sends to this contract. -contract SaleClockAuction is ClockAuction { - - // @dev Sanity check that allows us to ensure that we are pointing to the - // right auction in our setSaleAuctionAddress() call. - bool public isSaleClockAuction = true; - - // Tracks last 5 sale price of gen0 kitty sales - uint256 public gen0SaleCount; - uint256[5] public lastGen0SalePrices; - - // Delegate constructor - function SaleClockAuction(address _nftAddr, uint256 _cut) public - ClockAuction(_nftAddr, _cut) {} - - /// @dev Creates and begins a new auction. - /// @param _tokenId - ID of token to auction, sender must be owner. - /// @param _startingPrice - Price of item (in wei) at beginning of auction. - /// @param _endingPrice - Price of item (in wei) at end of auction. - /// @param _duration - Length of auction (in seconds). - /// @param _seller - Seller, if not the message sender - function createAuction( - uint256 _tokenId, - uint256 _startingPrice, - uint256 _endingPrice, - uint256 _duration, - address _seller - ) - external - { - // Sanity check that no inputs overflow how many bits we've allocated - // to store them in the auction struct. - require(_startingPrice == uint256(uint128(_startingPrice))); - require(_endingPrice == uint256(uint128(_endingPrice))); - require(_duration == uint256(uint64(_duration))); - - require(msg.sender == address(nonFungibleContract)); - _escrow(_seller, _tokenId); - Auction memory auction = Auction( - _seller, - uint128(_startingPrice), - uint128(_endingPrice), - uint64(_duration), - uint64(now) - ); - _addAuction(_tokenId, auction); - } - - /// @dev Updates lastSalePrice if seller is the nft contract - /// Otherwise, works the same as default bid method. - function bid(uint256 _tokenId) - external - payable - { - // _bid verifies token ID size - address seller = tokenIdToAuction[_tokenId].seller; - uint256 price = _bid(_tokenId, msg.value); - _transfer(msg.sender, _tokenId); - - // If not a gen0 auction, exit - if (seller == address(nonFungibleContract)) { - // Track gen0 sale prices - lastGen0SalePrices[gen0SaleCount % 5] = price; - gen0SaleCount++; - } - } - - function averageGen0SalePrice() external view returns (uint256) { - uint256 sum = 0; - for (uint256 i = 0; i < 5; i++) { - sum += lastGen0SalePrices[i]; - } - return sum / 5; - } - -} - - -/// @title Handles creating auctions for sale and siring of kitties. -/// This wrapper of ReverseAuction exists only so that users can create -/// auctions with only one transaction. -contract KittyAuction is KittyBreeding { - - // @notice The auction contract variables are defined in KittyBase to allow - // us to refer to them in KittyOwnership to prevent accidental transfers. - // `saleAuction` refers to the auction for gen0 and p2p sale of kitties. - // `siringAuction` refers to the auction for siring rights of kitties. - - /// @dev Sets the reference to the sale auction. - /// @param _address - Address of sale contract. - function setSaleAuctionAddress(address _address) external onlyCEO { - SaleClockAuction candidateContract = SaleClockAuction(_address); - - // NOTE: verify that a contract is what we expect - https://github.com/Lunyr/crowdsale-contracts/blob/cfadd15986c30521d8ba7d5b6f57b4fefcc7ac38/contracts/LunyrToken.sol#L117 - require(candidateContract.isSaleClockAuction()); - - // Set the new contract address - saleAuction = candidateContract; - } - - /// @dev Sets the reference to the siring auction. - /// @param _address - Address of siring contract. - function setSiringAuctionAddress(address _address) external onlyCEO { - SiringClockAuction candidateContract = SiringClockAuction(_address); - - // NOTE: verify that a contract is what we expect - https://github.com/Lunyr/crowdsale-contracts/blob/cfadd15986c30521d8ba7d5b6f57b4fefcc7ac38/contracts/LunyrToken.sol#L117 - require(candidateContract.isSiringClockAuction()); - - // Set the new contract address - siringAuction = candidateContract; - } - - /// @dev Put a kitty up for auction. - /// Does some ownership trickery to create auctions in one tx. - function createSaleAuction( - uint256 _kittyId, - uint256 _startingPrice, - uint256 _endingPrice, - uint256 _duration - ) - external - whenNotPaused - { - // Auction contract checks input sizes - // If kitty is already on any auction, this will throw - // because it will be owned by the auction contract. - require(_owns(msg.sender, _kittyId)); - // Ensure the kitty is not pregnant to prevent the auction - // contract accidentally receiving ownership of the child. - // NOTE: the kitty IS allowed to be in a cooldown. - require(!isPregnant(_kittyId)); - _approve(_kittyId, saleAuction); - // Sale auction throws if inputs are invalid and clears - // transfer and sire approval after escrowing the kitty. - saleAuction.createAuction( - _kittyId, - _startingPrice, - _endingPrice, - _duration, - msg.sender - ); - } - - /// @dev Put a kitty up for auction to be sire. - /// Performs checks to ensure the kitty can be sired, then - /// delegates to reverse auction. - function createSiringAuction( - uint256 _kittyId, - uint256 _startingPrice, - uint256 _endingPrice, - uint256 _duration - ) - external - whenNotPaused - { - // Auction contract checks input sizes - // If kitty is already on any auction, this will throw - // because it will be owned by the auction contract. - require(_owns(msg.sender, _kittyId)); - require(isReadyToBreed(_kittyId)); - _approve(_kittyId, siringAuction); - // Siring auction throws if inputs are invalid and clears - // transfer and sire approval after escrowing the kitty. - siringAuction.createAuction( - _kittyId, - _startingPrice, - _endingPrice, - _duration, - msg.sender - ); - } - - /// @dev Completes a siring auction by bidding. - /// Immediately breeds the winning matron with the sire on auction. - /// @param _sireId - ID of the sire on auction. - /// @param _matronId - ID of the matron owned by the bidder. - function bidOnSiringAuction( - uint256 _sireId, - uint256 _matronId - ) - external - payable - whenNotPaused - { - // Auction contract checks input sizes - require(_owns(msg.sender, _matronId)); - require(isReadyToBreed(_matronId)); - require(_canBreedWithViaAuction(_matronId, _sireId)); - - // Define the current price of the auction. - uint256 currentPrice = siringAuction.getCurrentPrice(_sireId); - require(msg.value >= currentPrice + autoBirthFee); - - // Siring auction will throw if the bid fails. - siringAuction.bid.value(msg.value - autoBirthFee)(_sireId); - _breedWith(uint32(_matronId), uint32(_sireId)); - } - - /// @dev Transfers the balance of the sale auction contract - /// to the KittyCore contract. We use two-step withdrawal to - /// prevent two transfer calls in the auction bid function. - function withdrawAuctionBalances() external onlyCLevel { - saleAuction.withdrawBalance(); - siringAuction.withdrawBalance(); - } -} - - -/// @title all functions related to creating kittens -contract KittyMinting is KittyAuction { - - // Limits the number of cats the contract owner can ever create. - uint256 public constant PROMO_CREATION_LIMIT = 5000; - uint256 public constant GEN0_CREATION_LIMIT = 45000; - - // Constants for gen0 auctions. - uint256 public constant GEN0_STARTING_PRICE = 10 finney; - uint256 public constant GEN0_AUCTION_DURATION = 1 days; - - // Counts the number of cats the contract owner has created. - uint256 public promoCreatedCount; - uint256 public gen0CreatedCount; - - /// @dev we can create promo kittens, up to a limit. Only callable by COO - /// @param _genes the encoded genes of the kitten to be created, any value is accepted - /// @param _owner the future owner of the created kittens. Default to contract COO - function createPromoKitty(uint256 _genes, address _owner) external onlyCOO { - address kittyOwner = _owner; - if (kittyOwner == address(0)) { - kittyOwner = cooAddress; - } - require(promoCreatedCount < PROMO_CREATION_LIMIT); - - promoCreatedCount++; - _createKitty(0, 0, 0, _genes, kittyOwner); - } - - /// @dev Creates a new gen0 kitty with the given genes and - /// creates an auction for it. - function createGen0Auction(uint256 _genes) external onlyCOO { - require(gen0CreatedCount < GEN0_CREATION_LIMIT); - - uint256 kittyId = _createKitty(0, 0, 0, _genes, address(this)); - _approve(kittyId, saleAuction); - - saleAuction.createAuction( - kittyId, - _computeNextGen0Price(), - 0, - GEN0_AUCTION_DURATION, - address(this) - ); - - gen0CreatedCount++; - } - - /// @dev Computes the next gen0 auction starting price, given - /// the average of the past 5 prices + 50%. - function _computeNextGen0Price() internal view returns (uint256) { - uint256 avePrice = saleAuction.averageGen0SalePrice(); - - // Sanity check to ensure we don't overflow arithmetic - require(avePrice == uint256(uint128(avePrice))); - - uint256 nextPrice = avePrice + (avePrice / 2); - - // We never auction for less than starting price - if (nextPrice < GEN0_STARTING_PRICE) { - nextPrice = GEN0_STARTING_PRICE; - } - - return nextPrice; - } -} - - -/// @title CryptoKitties: Collectible, breedable, and oh-so-adorable cats on the Ethereum blockchain. -/// @author Axiom Zen (https://www.axiomzen.co) -/// @dev The main CryptoKitties contract, keeps track of kittens so they don't wander around and get lost. -contract KittyCore is KittyMinting { - - // This is the main CryptoKitties contract. In order to keep our code seperated into logical sections, - // we've broken it up in two ways. First, we have several seperately-instantiated sibling contracts - // that handle auctions and our super-top-secret genetic combination algorithm. The auctions are - // seperate since their logic is somewhat complex and there's always a risk of subtle bugs. By keeping - // them in their own contracts, we can upgrade them without disrupting the main contract that tracks - // kitty ownership. The genetic combination algorithm is kept seperate so we can open-source all of - // the rest of our code without making it _too_ easy for folks to figure out how the genetics work. - // Don't worry, I'm sure someone will reverse engineer it soon enough! - // - // Secondly, we break the core contract into multiple files using inheritence, one for each major - // facet of functionality of CK. This allows us to keep related code bundled together while still - // avoiding a single giant file with everything in it. The breakdown is as follows: - // - // - KittyBase: This is where we define the most fundamental code shared throughout the core - // functionality. This includes our main data storage, constants and data types, plus - // internal functions for managing these items. - // - // - KittyAccessControl: This contract manages the various addresses and constraints for operations - // that can be executed only by specific roles. Namely CEO, CFO and COO. - // - // - KittyOwnership: This provides the methods required for basic non-fungible token - // transactions, following the draft ERC-721 spec (https://github.com/ethereum/EIPs/issues/721). - // - // - KittyBreeding: This file contains the methods necessary to breed cats together, including - // keeping track of siring offers, and relies on an external genetic combination contract. - // - // - KittyAuctions: Here we have the public methods for auctioning or bidding on cats or siring - // services. The actual auction functionality is handled in two sibling contracts (one - // for sales and one for siring), while auction creation and bidding is mostly mediated - // through this facet of the core contract. - // - // - KittyMinting: This final facet contains the functionality we use for creating new gen0 cats. - // We can make up to 5000 "promo" cats that can be given away (especially important when - // the community is new), and all others can only be created and then immediately put up - // for auction via an algorithmically determined starting price. Regardless of how they - // are created, there is a hard limit of 50k gen0 cats. After that, it's all up to the - // community to breed, breed, breed! - - // Set in case the core contract is broken and an upgrade is required - address public newContractAddress; - - /// @notice Creates the main CryptoKitties smart contract instance. - function KittyCore() public { - // Starts paused. - paused = true; - - // the creator of the contract is the initial CEO - ceoAddress = msg.sender; - - // the creator of the contract is also the initial COO - cooAddress = msg.sender; - - // start with the mythical kitten 0 - so we don't have generation-0 parent issues - _createKitty(0, 0, 0, uint256(-1), address(0)); - } - - /// @dev Used to mark the smart contract as upgraded, in case there is a serious - /// breaking bug. This method does nothing but keep track of the new contract and - /// emit a message indicating that the new address is set. It's up to clients of this - /// contract to update to the new contract address in that case. (This contract will - /// be paused indefinitely if such an upgrade takes place.) - /// @param _v2Address new address - function setNewAddress(address _v2Address) external onlyCEO whenPaused { - // See README.md for updgrade plan - newContractAddress = _v2Address; - ContractUpgrade(_v2Address); - } - - /// @notice No tipping! - /// @dev Reject all Ether from being sent here, unless it's from one of the - /// two auction contracts. (Hopefully, we can prevent user accidents.) - function() external payable { - require( - msg.sender == address(saleAuction) || - msg.sender == address(siringAuction) - ); - } - - /// @notice Returns all the relevant information about a specific kitty. - /// @param _id The ID of the kitty of interest. - function getKitty(uint256 _id) - external - view - returns ( - bool isGestating, - bool isReady, - uint256 cooldownIndex, - uint256 nextActionAt, - uint256 siringWithId, - uint256 birthTime, - uint256 matronId, - uint256 sireId, - uint256 generation, - uint256 genes - ) { - Kitty storage kit = kitties[_id]; - - // if this variable is 0 then it's not gestating - isGestating = (kit.siringWithId != 0); - isReady = (kit.cooldownEndBlock <= block.number); - cooldownIndex = uint256(kit.cooldownIndex); - nextActionAt = uint256(kit.cooldownEndBlock); - siringWithId = uint256(kit.siringWithId); - birthTime = uint256(kit.birthTime); - matronId = uint256(kit.matronId); - sireId = uint256(kit.sireId); - generation = uint256(kit.generation); - genes = kit.genes; - } - - /// @dev Override unpause so it requires all external contract addresses - /// to be set before contract can be unpaused. Also, we can't have - /// newContractAddress set either, because then the contract was upgraded. - /// @notice This is public rather than external so we can call super.unpause - /// without using an expensive CALL. - function unpause() public onlyCEO whenPaused { - require(saleAuction != address(0)); - require(siringAuction != address(0)); - require(geneScience != address(0)); - require(newContractAddress == address(0)); - - // Actually unpause the contract. - super.unpause(); - } - - // @dev Allows the CFO to capture the balance available to the contract. - function withdrawBalance() external onlyCFO { - uint256 balance = this.balance; - // Subtract all the currently pregnant kittens we have, plus 1 of margin. - uint256 subtractFees = (pregnantKitties + 1) * autoBirthFee; - - if (balance > subtractFees) { - cfoAddress.send(balance - subtractFees); - } - } -} \ No newline at end of file diff --git a/slither/tools/slither_format/tests/real_world/0x5d0d76787d9d564061dd23f8209f804a3b8ad2f2_FoMo3Dlong.sol b/slither/tools/slither_format/tests/real_world/0x5d0d76787d9d564061dd23f8209f804a3b8ad2f2_FoMo3Dlong.sol deleted file mode 100644 index 8964f9ec2..000000000 --- a/slither/tools/slither_format/tests/real_world/0x5d0d76787d9d564061dd23f8209f804a3b8ad2f2_FoMo3Dlong.sol +++ /dev/null @@ -1,2058 +0,0 @@ -pragma solidity 0.4.25; - -// File: contracts\interface\PlayerBookInterface.sol - -interface PlayerBookInterface { - function getPlayerID(address _Addr) external returns (uint256); - function getPlayerName(uint256 _PID) external view returns (bytes32); - function getPlayerLAff(uint256 _PID) external view returns (uint256); - function getPlayerAddr(uint256 _PID) external view returns (address); - function getNameFee() external view returns (uint256); - function registerNameXIDFromDapp(address _Addr, bytes32 _Name, uint256 _affCode, bool _all) external payable returns(bool, uint256); - function registerNameXaddrFromDapp(address _Addr, bytes32 _Name, address _affCode, bool _all) external payable returns(bool, uint256); - function registerNameXnameFromDapp(address _Addr, bytes32 _Name, bytes32 _affCode, bool _all) external payable returns(bool, uint256); -} - -// File: contracts\library\SafeMath.sol - -/** - * @title SafeMath v0.1.9 - * @dev Math operations with safety checks that throw on error - * change notes: original SafeMath library from OpenZeppelin modified by Inventor - * - added sqrt - * - added sq - * - added pwr - * - changed asserts to requires with error log outputs - * - removed div, its useless - */ -library SafeMath { - - /** - * @dev Multiplies two numbers, throws on overflow. - */ - function mul(uint256 a, uint256 b) - internal - pure - returns (uint256 c) - { - if (a == 0) { - return 0; - } - c = a * b; - require(c / a == b, "SafeMath mul failed"); - return c; - } - - /** - * @dev Integer division of two numbers, truncating the quotient. - */ - function div(uint256 a, uint256 b) internal pure returns (uint256) { - // assert(b > 0); // Solidity automatically throws when dividing by 0 - uint256 c = a / b; - // assert(a == b * c + a % b); // There is no case in which this doesn't hold - return c; - } - - /** - * @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend). - */ - function sub(uint256 a, uint256 b) - internal - pure - returns (uint256) - { - require(b <= a, "SafeMath sub failed"); - return a - b; - } - - /** - * @dev Adds two numbers, throws on overflow. - */ - function add(uint256 a, uint256 b) - internal - pure - returns (uint256 c) - { - c = a + b; - require(c >= a, "SafeMath add failed"); - return c; - } - - /** - * @dev gives square root of given x. - */ - function sqrt(uint256 x) - internal - pure - returns (uint256 y) - { - uint256 z = ((add(x,1)) / 2); - y = x; - while (z < y) - { - y = z; - z = ((add((x / z),z)) / 2); - } - } - - /** - * @dev gives square. multiplies x by x - */ - function sq(uint256 x) - internal - pure - returns (uint256) - { - return (mul(x,x)); - } - - /** - * @dev x to the power of y - */ - function pwr(uint256 x, uint256 y) - internal - pure - returns (uint256) - { - if (x==0) - return (0); - else if (y==0) - return (1); - else - { - uint256 z = x; - for (uint256 i=1; i < y; i++) - z = mul(z,x); - return (z); - } - } -} - -// File: contracts\library\UintCompressor.sol - -/** -* @title -UintCompressor- v0.1.9 -* ┌┬┐┌─┐┌─┐┌┬┐ ╦╦ ╦╔═╗╔╦╗ ┌─┐┬─┐┌─┐┌─┐┌─┐┌┐┌┌┬┐┌─┐ -* │ ├┤ ├─┤│││ ║║ ║╚═╗ ║ ├─┘├┬┘├┤ └─┐├┤ │││ │ └─┐ -* ┴ └─┘┴ ┴┴ ┴ ╚╝╚═╝╚═╝ ╩ ┴ ┴└─└─┘└─┘└─┘┘└┘ ┴ └─┘ -* _____ _____ -* (, / /) /) /) (, / /) /) -* ┌─┐ / _ (/_ // // / _ // _ __ _(/ -* ├─┤ ___/___(/_/(__(_/_(/_(/_ ___/__/_)_(/_(_(_/ (_(_(_ -* ┴ ┴ / / .-/ _____ (__ / -* (__ / (_/ (, / /)™ -* / __ __ __ __ _ __ __ _ _/_ _ _(/ -* ┌─┐┬─┐┌─┐┌┬┐┬ ┬┌─┐┌┬┐ /__/ (_(__(_)/ (_/_)_(_)/ (_(_(_(__(/_(_(_ -* ├─┘├┬┘│ │ │││ ││ │ (__ / .-/ © Jekyll Island Inc. 2018 -* ┴ ┴└─└─┘─┴┘└─┘└─┘ ┴ (_/ -* _ _ __ __ _ ____ ___ __ _ _ ____ ____ ____ ____ ____ __ ____ -*===/ )( \ ( ) ( ( \(_ _)===/ __) / \ ( \/ )( _ \( _ \( __)/ ___)/ ___) / \ ( _ \===* -* ) \/ ( )( / / )( ( (__ ( O )/ \/ \ ) __/ ) / ) _) \___ \\___ \( O ) ) / -*===\____/ (__) \_)__) (__)====\___) \__/ \_)(_/(__) (__\_)(____)(____/(____/ \__/ (__\_)===* -* -* ╔═╗┌─┐┌┐┌┌┬┐┬─┐┌─┐┌─┐┌┬┐ ╔═╗┌─┐┌┬┐┌─┐ ┌──────────┐ -* ║ │ ││││ │ ├┬┘├─┤│ │ ║ │ │ ││├┤ │ Inventor │ -* ╚═╝└─┘┘└┘ ┴ ┴└─┴ ┴└─┘ ┴ ╚═╝└─┘─┴┘└─┘ └──────────┘ -*/ - -library UintCompressor { - using SafeMath for *; - - function insert(uint256 _Var, uint256 _Include, uint256 _Start, uint256 _End) - internal - pure - returns(uint256) - { - // check conditions - require(_End < 77 && _Start < 77, "start/end must be less than 77"); - require(_End >= _Start, "end must be >= start"); - - // format our start/end points - _End = exponent(_End).mul(10); - _Start = exponent(_Start); - - // check that the include data fits into its segment - require(_Include < (_End / _Start)); - - // build middle - if (_Include > 0) - _Include = _Include.mul(_Start); - - return((_Var.sub((_Var / _Start).mul(_Start))).add(_Include).add((_Var / _End).mul(_End))); - } - - function extract(uint256 _Input, uint256 _Start, uint256 _End) - internal - pure - returns(uint256) - { - // check conditions - require(_End < 77 && _Start < 77, "start/end must be less than 77"); - require(_End >= _Start, "end must be >= start"); - - // format our start/end points - _End = exponent(_End).mul(10); - _Start = exponent(_Start); - - // return requested section - return((((_Input / _Start).mul(_Start)).sub((_Input / _End).mul(_End))) / _Start); - } - - function exponent(uint256 _Position) - private - pure - returns(uint256) - { - return((10).pwr(_Position)); - } -} - -// File: contracts\library\NameFilter.sol - -/** -* @title -Name Filter- v0.1.9 -* ┌┬┐┌─┐┌─┐┌┬┐ ╦╦ ╦╔═╗╔╦╗ ┌─┐┬─┐┌─┐┌─┐┌─┐┌┐┌┌┬┐┌─┐ -* │ ├┤ ├─┤│││ ║║ ║╚═╗ ║ ├─┘├┬┘├┤ └─┐├┤ │││ │ └─┐ -* ┴ └─┘┴ ┴┴ ┴ ╚╝╚═╝╚═╝ ╩ ┴ ┴└─└─┘└─┘└─┘┘└┘ ┴ └─┘ -* _____ _____ -* (, / /) /) /) (, / /) /) -* ┌─┐ / _ (/_ // // / _ // _ __ _(/ -* ├─┤ ___/___(/_/(__(_/_(/_(/_ ___/__/_)_(/_(_(_/ (_(_(_ -* ┴ ┴ / / .-/ _____ (__ / -* (__ / (_/ (, / /)™ -* / __ __ __ __ _ __ __ _ _/_ _ _(/ -* ┌─┐┬─┐┌─┐┌┬┐┬ ┬┌─┐┌┬┐ /__/ (_(__(_)/ (_/_)_(_)/ (_(_(_(__(/_(_(_ -* ├─┘├┬┘│ │ │││ ││ │ (__ / .-/ © Jekyll Island Inc. 2018 -* ┴ ┴└─└─┘─┴┘└─┘└─┘ ┴ (_/ -* _ __ _ ____ ____ _ _ _____ ____ ___ -*=============| |\ | / /\ | |\/| | |_ =====| |_ | | | | | | | |_ | |_)==============* -*=============|_| \| /_/--\ |_| | |_|__=====|_| |_| |_|__ |_| |_|__ |_| \==============* -* -* ╔═╗┌─┐┌┐┌┌┬┐┬─┐┌─┐┌─┐┌┬┐ ╔═╗┌─┐┌┬┐┌─┐ ┌──────────┐ -* ║ │ ││││ │ ├┬┘├─┤│ │ ║ │ │ ││├┤ │ Inventor │ -* ╚═╝└─┘┘└┘ ┴ ┴└─┴ ┴└─┘ ┴ ╚═╝└─┘─┴┘└─┘ └──────────┘ -*/ - -library NameFilter { - /** - * @dev filters name strings - * -converts uppercase to lower case. - * -makes sure it does not start/end with a space - * -makes sure it does not contain multiple spaces in a row - * -cannot be only numbers - * -cannot start with 0x - * -restricts characters to A-Z, a-z, 0-9, and space. - * @return reprocessed string in bytes32 format - */ - function nameFilter(string _Input) - internal - - returns(bytes32) - { - bytes memory _temp = bytes(_Input); - uint256 _length = _temp.length; - - //sorry limited to 32 characters - require (_length <= 32 && _length > 0, "string must be between 1 and 32 characters"); - // make sure it doesnt start with or end with space - require(_temp[0] != 0x20 && _temp[_length-1] != 0x20, "string cannot start or end with space"); - // make sure first two characters are not 0x - if (_temp[0] == 0x30) - { - require(_temp[1] != 0x78, "string cannot start with 0x"); - require(_temp[1] != 0x58, "string cannot start with 0X"); - } - - // create a bool to track if we have a non number character - bool _hasNonNumber; - - // convert & check - for (uint256 i = 0; i < _length; i++) - { - // if its uppercase A-Z - if (_temp[i] > 0x40 && _temp[i] < 0x5b) - { - // convert to lower case a-z - _temp[i] = byte(uint(_temp[i]) + 32); - - // we have a non number - if (_hasNonNumber == false) - _hasNonNumber = true; - } else { - require - ( - // require character is a space - _temp[i] == 0x20 || - // OR lowercase a-z - (_temp[i] > 0x60 && _temp[i] < 0x7b) || - // or 0-9 - (_temp[i] > 0x2f && _temp[i] < 0x3a), - "string contains invalid characters" - ); - // make sure theres not 2x spaces in a row - if (_temp[i] == 0x20) - require( _temp[i+1] != 0x20, "string cannot contain consecutive spaces"); - - // see if we have a character other than a number - if (_hasNonNumber == false && (_temp[i] < 0x30 || _temp[i] > 0x39)) - _hasNonNumber = true; - } - } - - require(_hasNonNumber == true, "string cannot be only numbers"); - - bytes32 _ret; - assembly { - _ret := mload(add(_temp, 32)) - } - return (_ret); - } -} - -// File: contracts\library\F3DKeysCalcLong.sol - -//============================================================================== -// | _ _ _ | _ . -// |<(/_\/ (_(_||(_ . -//=======/====================================================================== -library F3DKeysCalcLong { - using SafeMath for *; - /** - * @dev calculates number of keys received given X eth - * _curEth current amount of eth in contract - * _newEth eth being spent - * @return amount of ticket purchased - */ - function keysRec(uint256 _CurEth, uint256 _NewEth) - internal - pure - returns (uint256) - { - return(keys((_CurEth).add(_NewEth)).sub(keys(_CurEth))); - } - - /** - * @dev calculates amount of eth received if you sold X keys - * _curKeys current amount of keys that exist - * _sellKeys amount of keys you wish to sell - * @return amount of eth received - */ - function ethRec(uint256 _CurKeys, uint256 _SellKeys) - internal - pure - returns (uint256) - { - return((eth(_CurKeys)).sub(eth(_CurKeys.sub(_SellKeys)))); - } - - /** - * @dev calculates how many keys would exist with given an amount of eth - * _eth eth "in contract" - * @return number of keys that would exist - */ - function keys(uint256 _Eth) - internal - pure - returns(uint256) - { - return ((((((_Eth).mul(1000000000000000000)).mul(312500000000000000000000000)).add(5624988281256103515625000000000000000000000000000000000000000000)).sqrt()).sub(74999921875000000000000000000000)) / (156250000); - } - - /** - * @dev calculates how much eth would be in contract given a number of keys - * _keys number of keys "in contract" - * @return eth that would exists - */ - function eth(uint256 _Keys) - internal - pure - returns(uint256) - { - return ((78125000).mul(_Keys.sq()).add(((149999843750000).mul(_Keys.mul(1000000000000000000))) / (2))) / ((1000000000000000000).sq()); - } -} - -// File: contracts\library\F3Ddatasets.sol - -//============================================================================== -// __|_ _ __|_ _ . -// _\ | | |_|(_ | _\ . -//============================================================================== -library F3Ddatasets { - //compressedData key - // [76-33][32][31][30][29][28-18][17][16-6][5-3][2][1][0] - // 0 - new player (bool) - // 1 - joined round (bool) - // 2 - new leader (bool) - // 3-5 - air drop tracker (uint 0-999) - // 6-16 - round end time - // 17 - winnerTeam - // 18 - 28 timestamp - // 29 - team - // 30 - 0 = reinvest (round), 1 = buy (round), 2 = buy (ico), 3 = reinvest (ico) - // 31 - airdrop happened bool - // 32 - airdrop tier - // 33 - airdrop amount won - //compressedIDs key - // [77-52][51-26][25-0] - // 0-25 - pID - // 26-51 - winPID - // 52-77 - rID - struct EventReturns { - uint256 compressedData; - uint256 compressedIDs; - address winnerAddr; // winner address - bytes32 winnerName; // winner name - uint256 amountWon; // amount won - uint256 newPot; // amount in new pot - uint256 P3DAmount; // amount distributed to p3d - uint256 genAmount; // amount distributed to gen - uint256 potAmount; // amount added to pot - } - struct Player { - address addr; // player address - bytes32 name; // player name - uint256 win; // winnings vault - uint256 gen; // general vault - uint256 aff; // affiliate vault - uint256 lrnd; // last round played - uint256 laff; // last affiliate id used - } - struct PlayerRounds { - uint256 eth; // eth player has added to round (used for eth limiter) - uint256 keys; // keys - uint256 mask; // player mask - uint256 ico; // ICO phase investment - } - struct Round { - uint256 plyr; // pID of player in lead， lead领导吗？ - uint256 team; // tID of team in lead - uint256 end; // time ends/ended - bool ended; // has round end function been ran 这个开关值得研究下 - uint256 strt; // time round started - uint256 keys; // keys - uint256 eth; // total eth in - uint256 pot; // eth to pot (during round) / final amount paid to winner (after round ends) - uint256 mask; // global mask - uint256 ico; // total eth sent in during ICO phase - uint256 icoGen; // total eth for gen during ICO phase - uint256 icoAvg; // average key price for ICO phase - } - struct TeamFee { - uint256 gen; // % of buy in thats paid to key holders of current round - uint256 p3d; // % of buy in thats paid to p3d holders - } - struct PotSplit { - uint256 gen; // % of pot thats paid to key holders of current round - uint256 p3d; // % of pot thats paid to p3d holders - } -} - -// File: contracts\F3Devents.sol - -contract F3Devents { - // fired whenever a player registers a name - event OnNewName - ( - uint256 indexed playerID, - address indexed playerAddress, - bytes32 indexed playerName, - bool isNewPlayer, - uint256 affiliateID, - address affiliateAddress, - bytes32 affiliateName, - uint256 amountPaid, - uint256 timeStamp - ); - - // fired at end of buy or reload - event OnEndTx - ( - uint256 compressedData, - uint256 compressedIDs, - bytes32 playerName, - address playerAddress, - uint256 ethIn, - uint256 keysBought, - address winnerAddr, - bytes32 winnerName, - uint256 amountWon, - uint256 newPot, - uint256 P3DAmount, - uint256 genAmount, - uint256 potAmount, - uint256 airDropPot - ); - - // fired whenever theres a withdraw - event OnWithdraw - ( - uint256 indexed playerID, - address playerAddress, - bytes32 playerName, - uint256 ethOut, - uint256 timeStamp - ); - - // fired whenever a withdraw forces end round to be ran - event OnWithdrawAndDistribute - ( - address playerAddress, - bytes32 playerName, - uint256 ethOut, - uint256 compressedData, - uint256 compressedIDs, - address winnerAddr, - bytes32 winnerName, - uint256 amountWon, - uint256 newPot, - uint256 P3DAmount, - uint256 genAmount - ); - - // (fomo3d long only) fired whenever a player tries a buy after round timer - // hit zero, and causes end round to be ran. - event OnBuyAndDistribute - ( - address playerAddress, - bytes32 playerName, - uint256 ethIn, - uint256 compressedData, - uint256 compressedIDs, - address winnerAddr, - bytes32 winnerName, - uint256 amountWon, - uint256 newPot, - uint256 P3DAmount, - uint256 genAmount - ); - - // (fomo3d long only) fired whenever a player tries a reload after round timer - // hit zero, and causes end round to be ran. - event OnReLoadAndDistribute - ( - address playerAddress, - bytes32 playerName, - uint256 compressedData, - uint256 compressedIDs, - address winnerAddr, - bytes32 winnerName, - uint256 amountWon, - uint256 newPot, - uint256 P3DAmount, - uint256 genAmount - ); - - // fired whenever an affiliate is paid - event OnAffiliatePayout - ( - uint256 indexed affiliateID, - address affiliateAddress, - bytes32 affiliateName, - uint256 indexed roundID, - uint256 indexed buyerID, - uint256 amount, - uint256 timeStamp - ); - - // received pot swap deposit - event OnPotSwapDeposit - ( - uint256 roundID, - uint256 amountAddedToPot - ); -} - -// File: contracts\modularLong.sol - -contract Modularlong is F3Devents {} - -// File: contracts\FoMo3Dlong.sol - -contract FoMo3Dlong is Modularlong { - using SafeMath for *; - using NameFilter for string; - using F3DKeysCalcLong for uint256; - - - //TODO: - //JIincForwarderInterface constant private Jekyll_Island_Inc = JIincForwarderInterface(0x508D1c04cd185E693d22125f3Cc6DC81F7Ce9477); - PlayerBookInterface constant private PlayerBook = PlayerBookInterface(0x19dB4339c0ad1BE41FE497795FF2c5263962a573); - - address public constant TEAMWALLET = 0xE9675cdAf47bab3Eef5B1f1c2b7f8d41cDcf9b29; - address[] public leaderWallets; -//============================================================================== -// _ _ _ |`. _ _ _ |_ | _ _ . -// (_(_)| |~|~|(_||_|| (_||_)|(/__\ . (game settings) -//=================_|=========================================================== - string constant public name = "Peach Will"; - string constant public symbol = "PW"; - uint256 private constant RNDEXTRA_ = 1 hours; //24 hours; // length of the very first ICO - uint256 private constant RNDGAP_ = 15 seconds; // length of ICO phase, set to 1 year for EOS. - uint256 constant private RNDINIT_ = 10 hours; //1 hours; // round timer starts at this - uint256 constant private RNDINC_ = 88 seconds; // every full key purchased adds this much to the timer - uint256 constant private RNDMAX_ = 10 hours; // 24 hours; // max length a round timer can be -//============================================================================== -// _| _ _|_ _ _ _ _|_ _ . -// (_|(_| | (_| _\(/_ | |_||_) . (data used to store game info that changes) -//=============================|================================================ - uint256 public airDropPot_; // person who gets the airdrop wins part of this pot - uint256 public airDropTracker_ = 0; // incremented each time a "qualified" tx occurs. used to determine winning air drop - uint256 public rID_; // round id number / total rounds that have happened -//**************** -// PLAYER DATA -//**************** - mapping (address => uint256) public pIDxAddr_; // (addr => pID) returns player id by address - mapping (bytes32 => uint256) public pIDxName_; // (name => pID) returns player id by name - mapping (uint256 => F3Ddatasets.Player) public plyr_; // (pID => data) player data - mapping (uint256 => mapping (uint256 => F3Ddatasets.PlayerRounds)) public plyrRnds_; // (pID => rID => data) player round data by player id & round id - mapping (uint256 => mapping (bytes32 => bool)) public plyrNames_; // (pID => name => bool) list of names a player owns. (used so you can change your display name amongst any name you own) -//**************** -// ROUND DATA -//**************** - mapping (uint256 => F3Ddatasets.Round) public round_; // (rID => data) round data - mapping (uint256 => mapping(uint256 => uint256)) public rndTmEth_; // (rID => tID => data) eth in per team, by round id and team id -//**************** -// TEAM FEE DATA , Team的费用分配数据 -//**************** - mapping (uint256 => F3Ddatasets.TeamFee) public fees_; // (team => fees) fee distribution by team - mapping (uint256 => F3Ddatasets.PotSplit) public potSplit_; // (team => fees) pot split distribution by team -//============================================================================== -// _ _ _ __|_ _ __|_ _ _ . -// (_(_)| |_\ | | |_|(_ | (_)| . (initial data setup upon contract deploy) -//============================================================================== - constructor() - public - { - // Team allocation structures - // 0 = whales - // 1 = bears - // 2 = sneks - // 3 = bulls - - // Team allocation percentages - // (F3D, P3D) + (Pot , Referrals, Community) - // Referrals / Community rewards are mathematically designed to come from the winner's share of the pot. - fees_[0] = F3Ddatasets.TeamFee(54,0); //20% to pot, 10% to aff, 10% to com, 5% to leader swap, 1% to air drop pot - fees_[1] = F3Ddatasets.TeamFee(41,0); //33% to pot, 10% to aff, 10% to com, 5% to leader swap, 1% to air drop pot - fees_[2] = F3Ddatasets.TeamFee(30,0); //44% to pot, 10% to aff, 10% to com, 5% to leader swap, 1% to air drop pot - fees_[3] = F3Ddatasets.TeamFee(40,0); //34% to pot, 10% to aff, 10% to com, 5% to leader swap, 1% to air drop pot - - // how to split up the final pot based on which team was picked - // (F3D, P3D) - potSplit_[0] = F3Ddatasets.PotSplit(37,0); //48% to winner, 10% to next round, 5% to com - potSplit_[1] = F3Ddatasets.PotSplit(34,0); //48% to winner, 13% to next round, 5% to com - potSplit_[2] = F3Ddatasets.PotSplit(25,0); //48% to winner, 22% to next round, 5% to com - potSplit_[3] = F3Ddatasets.PotSplit(32,0); //48% to winner, 15% to next round, 5% to com - - leaderWallets.length = 4; - leaderWallets[0]= 0x326d8d593195a3153f6d55d7791c10af9bcef597; - leaderWallets[1]= 0x15B474F7DE7157FA0dB9FaaA8b82761E78E804B9; - leaderWallets[2]= 0x0c2d482FBc1da4DaCf3CD05b6A5955De1A296fa8; - leaderWallets[3]= 0xD3d96E74aFAE57B5191DC44Bdb08b037355523Ba; - - } -//============================================================================== -// _ _ _ _|. |`. _ _ _ . -// | | |(_)(_||~|~|(/_| _\ . (these are safety checks) -//============================================================================== - /** - * @dev used to make sure no one can interact with contract until it has - * been activated. - */ - modifier isActivated() { - require(activated_ == true, "its not ready yet. check ?eta in discord"); - _; - } - - /** - * @dev prevents contracts from interacting with fomo3d - */ - modifier isHuman() { - address _Addr = msg.sender; - require (_Addr == tx.origin); - - uint256 _codeLength; - - assembly {_codeLength := extcodesize(_Addr)} - require(_codeLength == 0, "sorry humans only"); - _; - } - - /** - * @dev sets boundaries for incoming tx - */ - modifier isWithinLimits(uint256 _eth) { - require(_eth >= 1000000000, "pocket lint: not a valid currency"); - require(_eth <= 100000000000000000000000, "no vitalik, no"); - _; - } - - /** - * - */ - modifier onlyDevs() { - //TODO: - require( - msg.sender == 0xE9675cdAf47bab3Eef5B1f1c2b7f8d41cDcf9b29 || - msg.sender == 0x0020116131498D968DeBCF75E5A11F77e7e1CadE, - "only team just can activate" - ); - _; - } - -//============================================================================== -// _ |_ |. _ |` _ __|_. _ _ _ . -// |_)|_||_)||(_ ~|~|_|| |(_ | |(_)| |_\ . (use these to interact with contract) -//====|========================================================================= - /** - * @dev emergency buy uses last stored affiliate ID and team snek - */ - function() - isActivated() - isHuman() - isWithinLimits(msg.value) - external - payable - { - // set up our tx event data and determine if player is new or not - F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_); - - // fetch player id - uint256 _PID = pIDxAddr_[msg.sender]; - - // buy core - buyCore(_PID, plyr_[_PID].laff, 2, _eventData_); - } - - /** - * @dev converts all incoming ethereum to keys. - * -functionhash- 0x8f38f309 (using ID for affiliate) - * -functionhash- 0x98a0871d (using address for affiliate) - * -functionhash- 0xa65b37a1 (using name for affiliate) - * _affCode the ID/address/name of the player who gets the affiliate fee - * _Team what team is the player playing for? - */ - function buyXid(uint256 _AffCode, uint256 _Team) - isActivated() - isHuman() - isWithinLimits(msg.value) - public - payable - { - // set up our tx event data and determine if player is new or not - F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_); - - // fetch player id - uint256 _PID = pIDxAddr_[msg.sender]; - - // manage affiliate residuals - // if no affiliate code was given or player tried to use their own, lolz - if (_AffCode == 0 || _AffCode == _PID) - { - // use last stored affiliate code - _AffCode = plyr_[_PID].laff; - - // if affiliate code was given & its not the same as previously stored - } else if (_AffCode != plyr_[_PID].laff) { - // update last affiliate - plyr_[_PID].laff = _AffCode; - } - - // verify a valid team was selected - _Team = verifyTeam(_Team); - - // buy core - buyCore(_PID, _AffCode, _Team, _eventData_); - } - - function buyXaddr(address _AffCode, uint256 _Team) - isActivated() - isHuman() - isWithinLimits(msg.value) - public - payable - { - // set up our tx event data and determine if player is new or not - F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_); - - // fetch player id - uint256 _PID = pIDxAddr_[msg.sender]; - - // manage affiliate residuals - uint256 _AffID; - // if no affiliate code was given or player tried to use their own, lolz - if (_AffCode == address(0) || _AffCode == msg.sender) - { - // use last stored affiliate code - _AffID = plyr_[_PID].laff; - - // if affiliate code was given - } else { - // get affiliate ID from aff Code - _AffID = pIDxAddr_[_AffCode]; - - // if affID is not the same as previously stored - if (_AffID != plyr_[_PID].laff) - { - // update last affiliate - plyr_[_PID].laff = _AffID; - } - } - - // verify a valid team was selected - _Team = verifyTeam(_Team); - - // buy core - buyCore(_PID, _AffID, _Team, _eventData_); - } - - function buyXname(bytes32 _AffCode, uint256 _Team) - isActivated() - isHuman() - isWithinLimits(msg.value) - public - payable - { - // set up our tx event data and determine if player is new or not - F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_); - - // fetch player id - uint256 _PID = pIDxAddr_[msg.sender]; - - // manage affiliate residuals - uint256 _AffID; - // if no affiliate code was given or player tried to use their own, lolz - if (_AffCode == '' || _AffCode == plyr_[_PID].name) - { - // use last stored affiliate code - _AffID = plyr_[_PID].laff; - - // if affiliate code was given - } else { - // get affiliate ID from aff Code - _AffID = pIDxName_[_AffCode]; - - // if affID is not the same as previously stored - if (_AffID != plyr_[_PID].laff) - { - // update last affiliate - plyr_[_PID].laff = _AffID; - } - } - - // verify a valid team was selected - _Team = verifyTeam(_Team); - - // buy core - buyCore(_PID, _AffID, _Team, _eventData_); - } - - /** - * @dev essentially the same as buy, but instead of you sending ether - * from your wallet, it uses your unwithdrawn earnings. - * -functionhash- 0x349cdcac (using ID for affiliate) - * -functionhash- 0x82bfc739 (using address for affiliate) - * -functionhash- 0x079ce327 (using name for affiliate) - * _affCode the ID/address/name of the player who gets the affiliate fee - * _Team what team is the player playing for? - * _eth amount of earnings to use (remainder returned to gen vault) - */ - function reLoadXid(uint256 _AffCode, uint256 _Team, uint256 _Eth) - isActivated() - isHuman() - isWithinLimits(_Eth) - public - { - // set up our tx event data - F3Ddatasets.EventReturns memory _eventData_; - - // fetch player ID - uint256 _PID = pIDxAddr_[msg.sender]; - - // manage affiliate residuals - // if no affiliate code was given or player tried to use their own, lolz - if (_AffCode == 0 || _AffCode == _PID) - { - // use last stored affiliate code - _AffCode = plyr_[_PID].laff; - - // if affiliate code was given & its not the same as previously stored - } else if (_AffCode != plyr_[_PID].laff) { - // update last affiliate - plyr_[_PID].laff = _AffCode; - } - - // verify a valid team was selected - _Team = verifyTeam(_Team); - - // reload core - reLoadCore(_PID, _AffCode, _Team, _Eth, _eventData_); - } - - function reLoadXaddr(address _AffCode, uint256 _Team, uint256 _Eth) - isActivated() - isHuman() - isWithinLimits(_Eth) - public - { - // set up our tx event data - F3Ddatasets.EventReturns memory _eventData_; - - // fetch player ID - uint256 _PID = pIDxAddr_[msg.sender]; - - // manage affiliate residuals - uint256 _AffID; - // if no affiliate code was given or player tried to use their own, lolz - if (_AffCode == address(0) || _AffCode == msg.sender) - { - // use last stored affiliate code - _AffID = plyr_[_PID].laff; - - // if affiliate code was given - } else { - // get affiliate ID from aff Code - _AffID = pIDxAddr_[_AffCode]; - - // if affID is not the same as previously stored - if (_AffID != plyr_[_PID].laff) - { - // update last affiliate - plyr_[_PID].laff = _AffID; - } - } - - // verify a valid team was selected - _Team = verifyTeam(_Team); - - // reload core - reLoadCore(_PID, _AffID, _Team, _Eth, _eventData_); - } - - function reLoadXname(bytes32 _AffCode, uint256 _Team, uint256 _Eth) - isActivated() - isHuman() - isWithinLimits(_Eth) - public - { - // set up our tx event data - F3Ddatasets.EventReturns memory _eventData_; - - // fetch player ID - uint256 _PID = pIDxAddr_[msg.sender]; - - // manage affiliate residuals - uint256 _AffID; - // if no affiliate code was given or player tried to use their own, lolz - if (_AffCode == '' || _AffCode == plyr_[_PID].name) - { - // use last stored affiliate code - _AffID = plyr_[_PID].laff; - - // if affiliate code was given - } else { - // get affiliate ID from aff Code - _AffID = pIDxName_[_AffCode]; - - // if affID is not the same as previously stored - if (_AffID != plyr_[_PID].laff) - { - // update last affiliate - plyr_[_PID].laff = _AffID; - } - } - - // verify a valid team was selected - _Team = verifyTeam(_Team); - - // reload core - reLoadCore(_PID, _AffID, _Team, _Eth, _eventData_); - } - - /** - * @dev withdraws all of your earnings. - * -functionhash- 0x3ccfd60b - */ - function withdraw() - isActivated() - isHuman() - external - { - // setup local rID - uint256 _RID = rID_; - - // grab time - uint256 _now = now; - - // fetch player ID - uint256 _PID = pIDxAddr_[msg.sender]; - - // setup temp var for player eth - uint256 _eth; - - // check to see if round has ended and no one has run round end yet - if (_now > round_[_RID].end && round_[_RID].ended == false && round_[_RID].plyr != 0) - { - // set up our tx event data - F3Ddatasets.EventReturns memory _eventData_; - - // end the round (distributes pot) - round_[_RID].ended = true; - _eventData_ = endRound(_eventData_); - - // get their earnings - _eth = withdrawEarnings(_PID); - - // gib moni - if (_eth > 0) - plyr_[_PID].addr.transfer(_eth); - - // build event data - _eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000); - _eventData_.compressedIDs = _eventData_.compressedIDs + _PID; - - // fire withdraw and distribute event - emit F3Devents.OnWithdrawAndDistribute - ( - msg.sender, - plyr_[_PID].name, - _eth, - _eventData_.compressedData, - _eventData_.compressedIDs, - _eventData_.winnerAddr, - _eventData_.winnerName, - _eventData_.amountWon, - _eventData_.newPot, - _eventData_.P3DAmount, - _eventData_.genAmount - ); - - // in any other situation - } else { - // get their earnings - _eth = withdrawEarnings(_PID); - - // gib moni - if (_eth > 0) - plyr_[_PID].addr.transfer(_eth); - - // fire withdraw event - emit F3Devents.OnWithdraw(_PID, msg.sender, plyr_[_PID].name, _eth, _now); - } - } - - /** - * @dev use these to register names. they are just wrappers that will send the - * registration requests to the PlayerBook contract. So registering here is the - * same as registering there. UI will always display the last name you registered. - * but you will still own all previously registered names to use as affiliate - * links. - * - must pay a registration fee. - * - name must be unique - * - names will be converted to lowercase - * - name cannot start or end with a space - * - cannot have more than 1 space in a row - * - cannot be only numbers - * - cannot start with 0x - * - name must be at least 1 char - * - max length of 32 characters long - * - allowed characters: a-z, 0-9, and space - * -functionhash- 0x921dec21 (using ID for affiliate) - * -functionhash- 0x3ddd4698 (using address for affiliate) - * -functionhash- 0x685ffd83 (using name for affiliate) - * _NameString players desired name - * _affCode affiliate ID, address, or name of who referred you - * _all set to true if you want this to push your info to all games - * (this might cost a lot of gas) - */ - function registerNameXID(string _NameString, uint256 _AffCode, bool _All) - isHuman() - external - payable - { - bytes32 _Name = _NameString.nameFilter(); - address _Addr = msg.sender; - uint256 _paid = msg.value; - (bool _isNewPlayer, uint256 _AffID) = PlayerBook.registerNameXIDFromDapp.value(_paid)(_Addr, _Name, _AffCode, _All); - - uint256 _PID = pIDxAddr_[_Addr]; - - // fire event - emit F3Devents.OnNewName(_PID, _Addr, _Name, _isNewPlayer, _AffID, plyr_[_AffID].addr, plyr_[_AffID].name, _paid, now); - } - - function registerNameXaddr(string _NameString, address _AffCode, bool _All) - isHuman() - external - payable - { - bytes32 _Name = _NameString.nameFilter(); - address _Addr = msg.sender; - uint256 _paid = msg.value; - (bool _isNewPlayer, uint256 _AffID) = PlayerBook.registerNameXaddrFromDapp.value(msg.value)(msg.sender, _Name, _AffCode, _All); - - uint256 _PID = pIDxAddr_[_Addr]; - - // fire event - emit F3Devents.OnNewName(_PID, _Addr, _Name, _isNewPlayer, _AffID, plyr_[_AffID].addr, plyr_[_AffID].name, _paid, now); - } - - function registerNameXname(string _NameString, bytes32 _AffCode, bool _All) - isHuman() - external - payable - { - bytes32 _Name = _NameString.nameFilter(); - address _Addr = msg.sender; - uint256 _paid = msg.value; - (bool _isNewPlayer, uint256 _AffID) = PlayerBook.registerNameXnameFromDapp.value(msg.value)(msg.sender, _Name, _AffCode, _All); - - uint256 _PID = pIDxAddr_[_Addr]; - - // fire event - emit F3Devents.OnNewName(_PID, _Addr, _Name, _isNewPlayer, _AffID, plyr_[_AffID].addr, plyr_[_AffID].name, _paid, now); - } -//============================================================================== -// _ _ _|__|_ _ _ _ . -// (_|(/_ | | (/_| _\ . (for UI & viewing things on etherscan) -//=====_|======================================================================= - /** - * @dev return the price buyer will pay for next 1 individual key. - * -functionhash- 0x018a25e8 - * @return price for next key bought (in wei format) - */ - function getBuyPrice() - external - view - returns(uint256) - { - // setup local rID - uint256 _RID = rID_; - - // grab time - uint256 _now = now; - - // are we in a round? - if (_now > round_[_RID].strt + RNDGAP_ && (_now <= round_[_RID].end || (_now > round_[_RID].end && round_[_RID].plyr == 0))) - return ( (round_[_RID].keys.add(1000000000000000000)).ethRec(1000000000000000000) ); - else // rounds over. need price for new round - return ( 75000000000000 ); // init - } - - /** - * @dev returns time left. dont spam this, you'll ddos yourself from your node - * provider - * -functionhash- 0xc7e284b8 - * @return time left in seconds - */ - function getTimeLeft() - external - view - returns(uint256) - { - // setup local rID - uint256 _RID = rID_; - - // grab time - uint256 _now = now; - - if (_now < round_[_RID].end) - if (_now > round_[_RID].strt + RNDGAP_) - return( (round_[_RID].end).sub(_now) ); - else - return( (round_[_RID].strt + RNDGAP_).sub(_now) ); - else - return(0); - } - - /** - * @dev returns player earnings per vaults - * -functionhash- 0x63066434 - * @return winnings vault - * @return general vault - * @return affiliate vault - */ - function getPlayerVaults(uint256 _PID) - external - view - returns(uint256 ,uint256, uint256) - { - // setup local rID - uint256 _RID = rID_; - - // if round has ended. but round end has not been run (so contract has not distributed winnings) - if (now > round_[_RID].end && round_[_RID].ended == false && round_[_RID].plyr != 0) - { - // if player is winner - if (round_[_RID].plyr == _PID) - { - return - ( - (plyr_[_PID].win).add( ((round_[_RID].pot).mul(48)) / 100 ), - (plyr_[_PID].gen).add( getPlayerVaultsHelper(_PID, _RID).sub(plyrRnds_[_PID][_RID].mask) ), - plyr_[_PID].aff - ); - // if player is not the winner - } else { - return - ( - plyr_[_PID].win, - (plyr_[_PID].gen).add( getPlayerVaultsHelper(_PID, _RID).sub(plyrRnds_[_PID][_RID].mask) ), - plyr_[_PID].aff - ); - } - - // if round is still going on, or round has ended and round end has been ran - } else { - return - ( - plyr_[_PID].win, - (plyr_[_PID].gen).add(calcUnMaskedEarnings(_PID, plyr_[_PID].lrnd)), - plyr_[_PID].aff - ); - } - } - - /** - * solidity hates stack limits. this lets us avoid that hate - */ - function getPlayerVaultsHelper(uint256 _PID, uint256 _RID) - private - view - returns(uint256) - { - return( ((((round_[_RID].mask).add(((((round_[_RID].pot).mul(potSplit_[round_[_RID].team].gen)) / 100).mul(1000000000000000000)) / (round_[_RID].keys))).mul(plyrRnds_[_PID][_RID].keys)) / 1000000000000000000) ); - } - - /** - * @dev returns all current round info needed for front end - * -functionhash- 0x747dff42 - * @return eth invested during ICO phase - * @return round id - * @return total keys for round - * @return time round ends - * @return time round started - * @return current pot - * @return current team ID & player ID in lead - * @return current player in leads address - * @return current player in leads name - * @return whales eth in for round - * @return bears eth in for round - * @return sneks eth in for round - * @return bulls eth in for round - * @return airdrop tracker # & airdrop pot - */ - function getCurrentRoundInfo() - external - view - returns(uint256, uint256, uint256, uint256, uint256, uint256, uint256, address, bytes32, uint256, uint256, uint256, uint256, uint256) - { - // setup local rID - uint256 _RID = rID_; - - return - ( - round_[_RID].ico, //0 - _RID, //1 - round_[_RID].keys, //2 - round_[_RID].end, //3 - round_[_RID].strt, //4 - round_[_RID].pot, //5 - (round_[_RID].team + (round_[_RID].plyr * 10)), //6 - plyr_[round_[_RID].plyr].addr, //7 - plyr_[round_[_RID].plyr].name, //8 - rndTmEth_[_RID][0], //9 - rndTmEth_[_RID][1], //10 - rndTmEth_[_RID][2], //11 - rndTmEth_[_RID][3], //12 - airDropTracker_ + (airDropPot_ * 1000) //13 - ); - } - - /** - * @dev returns player info based on address. if no address is given, it will - * use msg.sender - * -functionhash- 0xee0b5d8b - * _Addr address of the player you want to lookup - * @return player ID - * @return player name - * @return keys owned (current round) - * @return winnings vault - * @return general vault - * @return affiliate vault - * @return player round eth - */ - function getPlayerInfoByAddress(address _Addr) - external - view - returns(uint256, bytes32, uint256, uint256, uint256, uint256, uint256) - { - // setup local rID - uint256 _RID = rID_; - - if (_Addr == address(0)) - { - _Addr == msg.sender; - } - uint256 _PID = pIDxAddr_[_Addr]; - - return - ( - _PID, //0 - plyr_[_PID].name, //1 - plyrRnds_[_PID][_RID].keys, //2 - plyr_[_PID].win, //3 - (plyr_[_PID].gen).add(calcUnMaskedEarnings(_PID, plyr_[_PID].lrnd)), //4 - plyr_[_PID].aff, //5 - plyrRnds_[_PID][_RID].eth //6 - ); - } - -//============================================================================== -// _ _ _ _ | _ _ . _ . -// (_(_)| (/_ |(_)(_||(_ . (this + tools + calcs + modules = our softwares engine) -//=====================_|======================================================= - /** - * @dev logic runs whenever a buy order is executed. determines how to handle - * incoming eth depending on if we are in an active round or not - */ - function buyCore(uint256 _PID, uint256 _AffID, uint256 _Team, F3Ddatasets.EventReturns memory _EventData_) - private - { - // setup local rID - uint256 _RID = rID_; - - // grab time - uint256 _now = now; - - // if round is active - if (_now > round_[_RID].strt + RNDGAP_ && (_now <= round_[_RID].end || (_now > round_[_RID].end && round_[_RID].plyr == 0))) - { - // call core - core(_RID, _PID, msg.value, _AffID, _Team, _EventData_); - - // if round is not active - } else { - // check to see if end round needs to be ran - if (_now > round_[_RID].end && round_[_RID].ended == false) - { - // end the round (distributes pot) & start new round - round_[_RID].ended = true; - _EventData_ = endRound(_EventData_); - - // build event data - _EventData_.compressedData = _EventData_.compressedData + (_now * 1000000000000000000); - _EventData_.compressedIDs = _EventData_.compressedIDs + _PID; - - // fire buy and distribute event - emit F3Devents.OnBuyAndDistribute - ( - msg.sender, - plyr_[_PID].name, - msg.value, - _EventData_.compressedData, - _EventData_.compressedIDs, - _EventData_.winnerAddr, - _EventData_.winnerName, - _EventData_.amountWon, - _EventData_.newPot, - _EventData_.P3DAmount, - _EventData_.genAmount - ); - } - - // put eth in players vault - plyr_[_PID].gen = plyr_[_PID].gen.add(msg.value); - } - } - - /** - * @dev logic runs whenever a reload order is executed. determines how to handle - * incoming eth depending on if we are in an active round or not - */ - function reLoadCore(uint256 _PID, uint256 _AffID, uint256 _Team, uint256 _Eth, F3Ddatasets.EventReturns memory _EventData_) - private - { - // setup local rID - uint256 _RID = rID_; - - // grab time - uint256 _now = now; - - // if round is active - if (_now > round_[_RID].strt + RNDGAP_ && (_now <= round_[_RID].end || (_now > round_[_RID].end && round_[_RID].plyr == 0))) - { - // get earnings from all vaults and return unused to gen vault - // because we use a custom safemath library. this will throw if player - // tried to spend more eth than they have. - plyr_[_PID].gen = withdrawEarnings(_PID).sub(_Eth); - - // call core - core(_RID, _PID, _Eth, _AffID, _Team, _EventData_); - - // if round is not active and end round needs to be ran - } else if (_now > round_[_RID].end && round_[_RID].ended == false) { - // end the round (distributes pot) & start new round - round_[_RID].ended = true; - _EventData_ = endRound(_EventData_); - - // build event data - _EventData_.compressedData = _EventData_.compressedData + (_now * 1000000000000000000); - _EventData_.compressedIDs = _EventData_.compressedIDs + _PID; - - // fire buy and distribute event - emit F3Devents.OnReLoadAndDistribute - ( - msg.sender, - plyr_[_PID].name, - _EventData_.compressedData, - _EventData_.compressedIDs, - _EventData_.winnerAddr, - _EventData_.winnerName, - _EventData_.amountWon, - _EventData_.newPot, - _EventData_.P3DAmount, - _EventData_.genAmount - ); - } - } - - /** - * @dev this is the core logic for any buy/reload that happens while a round - * is live. - */ - function core(uint256 _RID, uint256 _PID, uint256 _Eth, uint256 _AffID, uint256 _Team, F3Ddatasets.EventReturns memory _EventData_) - private - { - // if player is new to round - if (plyrRnds_[_PID][_RID].keys == 0) - _EventData_ = managePlayer(_PID, _EventData_); - - // early round eth limiter - if (round_[_RID].eth < 100000000000000000000 && plyrRnds_[_PID][_RID].eth.add(_Eth) > 1000000000000000000) - { - uint256 _availableLimit = (1000000000000000000).sub(plyrRnds_[_PID][_RID].eth); - uint256 _refund = _Eth.sub(_availableLimit); - plyr_[_PID].gen = plyr_[_PID].gen.add(_refund); - _Eth = _availableLimit; - } - - // if eth left is greater than min eth allowed (sorry no pocket lint) - if (_Eth > 1000000000) - { - - // mint the new keys - uint256 _keys = (round_[_RID].eth).keysRec(_Eth); - - // if they bought at least 1 whole key - if (_keys >= 1000000000000000000) - { - updateTimer(_keys, _RID); - - // set new leaders - if (round_[_RID].plyr != _PID) - round_[_RID].plyr = _PID; - if (round_[_RID].team != _Team) - round_[_RID].team = _Team; - - // set the new leader bool to true - _EventData_.compressedData = _EventData_.compressedData + 100; - } - - // manage airdrops - if (_Eth >= 100000000000000000) - { - airDropTracker_++; - if (airdrop() == true) - { - // gib muni - uint256 _prize; - if (_Eth >= 10000000000000000000) - { - // calculate prize and give it to winner - _prize = ((airDropPot_).mul(75)) / 100; - plyr_[_PID].win = (plyr_[_PID].win).add(_prize); - - // adjust airDropPot - airDropPot_ = (airDropPot_).sub(_prize); - - // let event know a tier 3 prize was won - _EventData_.compressedData += 300000000000000000000000000000000; - } else if (_Eth >= 1000000000000000000 && _Eth < 10000000000000000000) { - // calculate prize and give it to winner - _prize = ((airDropPot_).mul(50)) / 100; - plyr_[_PID].win = (plyr_[_PID].win).add(_prize); - - // adjust airDropPot - airDropPot_ = (airDropPot_).sub(_prize); - - // let event know a tier 2 prize was won - _EventData_.compressedData += 200000000000000000000000000000000; - } else if (_Eth >= 100000000000000000 && _Eth < 1000000000000000000) { - // calculate prize and give it to winner - _prize = ((airDropPot_).mul(25)) / 100; - plyr_[_PID].win = (plyr_[_PID].win).add(_prize); - - // adjust airDropPot - airDropPot_ = (airDropPot_).sub(_prize); - - // let event know a tier 3 prize was won - _EventData_.compressedData += 300000000000000000000000000000000; - } - // set airdrop happened bool to true - _EventData_.compressedData += 10000000000000000000000000000000; - // let event know how much was won - _EventData_.compressedData += _prize * 1000000000000000000000000000000000; - - // reset air drop tracker - airDropTracker_ = 0; - } - } - - // store the air drop tracker number (number of buys since last airdrop) - _EventData_.compressedData = _EventData_.compressedData + (airDropTracker_ * 1000); - - // update player - plyrRnds_[_PID][_RID].keys = _keys.add(plyrRnds_[_PID][_RID].keys); - plyrRnds_[_PID][_RID].eth = _Eth.add(plyrRnds_[_PID][_RID].eth); - - // update round - round_[_RID].keys = _keys.add(round_[_RID].keys); - round_[_RID].eth = _Eth.add(round_[_RID].eth); - rndTmEth_[_RID][_Team] = _Eth.add(rndTmEth_[_RID][_Team]); - - // distribute eth - _EventData_ = distributeExternal(_RID, _PID, _Eth, _AffID, _Team, _EventData_); - _EventData_ = distributeInternal(_RID, _PID, _Eth, _Team, _keys, _EventData_); - - // call end tx function to fire end tx event. - endTx(_PID, _Team, _Eth, _keys, _EventData_); - } - } -//============================================================================== -// _ _ | _ | _ _|_ _ _ _ . -// (_(_||(_|_||(_| | (_)| _\ . -//============================================================================== - /** - * @dev calculates unmasked earnings (just calculates, does not update mask) - * @return earnings in wei format - */ - function calcUnMaskedEarnings(uint256 _PID, uint256 _RIDlast) - private - view - returns(uint256) - { - return( (((round_[_RIDlast].mask).mul(plyrRnds_[_PID][_RIDlast].keys)) / (1000000000000000000)).sub(plyrRnds_[_PID][_RIDlast].mask) ); - } - - /** - * @dev returns the amount of keys you would get given an amount of eth. - * -functionhash- 0xce89c80c - * _RID round ID you want price for - * _eth amount of eth sent in - * @return keys received - */ - function calcKeysReceived(uint256 _RID, uint256 _Eth) - external - view - returns(uint256) - { - // grab time - uint256 _now = now; - - // are we in a round? - if (_now > round_[_RID].strt + RNDGAP_ && (_now <= round_[_RID].end || (_now > round_[_RID].end && round_[_RID].plyr == 0))) - return ( (round_[_RID].eth).keysRec(_Eth) ); - else // rounds over. need keys for new round - return ( (_Eth).keys() ); - } - - /** - * @dev returns current eth price for X keys. - * -functionhash- 0xcf808000 - * _keys number of keys desired (in 18 decimal format) - * @return amount of eth needed to send - */ - function iWantXKeys(uint256 _Keys) - external - view - returns(uint256) - { - // setup local rID - uint256 _RID = rID_; - - // grab time - uint256 _now = now; - - // are we in a round? - if (_now > round_[_RID].strt + RNDGAP_ && (_now <= round_[_RID].end || (_now > round_[_RID].end && round_[_RID].plyr == 0))) - return ( (round_[_RID].keys.add(_Keys)).ethRec(_Keys) ); - else // rounds over. need price for new round - return ( (_Keys).eth() ); - } -//============================================================================== -// _|_ _ _ | _ . -// | (_)(_)|_\ . -//============================================================================== - /** - * @dev receives name/player info from names contract - */ - function receivePlayerInfo(uint256 _PID, address _Addr, bytes32 _Name, uint256 _Laff) - external - { - require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm.."); - if (pIDxAddr_[_Addr] != _PID) - pIDxAddr_[_Addr] = _PID; - if (pIDxName_[_Name] != _PID) - pIDxName_[_Name] = _PID; - if (plyr_[_PID].addr != _Addr) - plyr_[_PID].addr = _Addr; - if (plyr_[_PID].name != _Name) - plyr_[_PID].name = _Name; - if (plyr_[_PID].laff != _Laff) - plyr_[_PID].laff = _Laff; - if (plyrNames_[_PID][_Name] == false) - plyrNames_[_PID][_Name] = true; - } - - /** - * @dev receives entire player name list - */ - function receivePlayerNameList(uint256 _PID, bytes32 _Name) - external - { - require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm.."); - if(plyrNames_[_PID][_Name] == false) - plyrNames_[_PID][_Name] = true; - } - - /** - * @dev gets existing or registers new pID. use this when a player may be new - * @return pID - */ - function determinePID(F3Ddatasets.EventReturns memory _EventData_) - private - returns (F3Ddatasets.EventReturns) - { - uint256 _PID = pIDxAddr_[msg.sender]; - // if player is new to this version of fomo3d - if (_PID == 0) - { - // grab their player ID, name and last aff ID, from player names contract - _PID = PlayerBook.getPlayerID(msg.sender); - bytes32 _Name = PlayerBook.getPlayerName(_PID); - uint256 _laff = PlayerBook.getPlayerLAff(_PID); - - // set up player account - pIDxAddr_[msg.sender] = _PID; - plyr_[_PID].addr = msg.sender; - - if (_Name != "") - { - pIDxName_[_Name] = _PID; - plyr_[_PID].name = _Name; - plyrNames_[_PID][_Name] = true; - } - - if (_laff != 0 && _laff != _PID) - plyr_[_PID].laff = _laff; - - // set the new player bool to true - _EventData_.compressedData = _EventData_.compressedData + 1; - } - return (_EventData_); - } - - /** - * @dev checks to make sure user picked a valid team. if not sets team - * to default (sneks) - */ - function verifyTeam(uint256 _Team) - private - pure - returns (uint256) - { - if (_Team < 0 || _Team > 3) - return(2); - else - return(_Team); - } - - /** - * @dev decides if round end needs to be run & new round started. and if - * player unmasked earnings from previously played rounds need to be moved. - */ - function managePlayer(uint256 _PID, F3Ddatasets.EventReturns memory _EventData_) - private - returns (F3Ddatasets.EventReturns) - { - // if player has played a previous round, move their unmasked earnings - // from that round to gen vault. - if (plyr_[_PID].lrnd != 0) - updateGenVault(_PID, plyr_[_PID].lrnd); - - // update player's last round played - plyr_[_PID].lrnd = rID_; - - // set the joined round bool to true - _EventData_.compressedData = _EventData_.compressedData + 10; - - return(_EventData_); - } - - /** - * @dev ends the round. manages paying out winner/splitting up pot - */ - function endRound(F3Ddatasets.EventReturns memory _EventData_) - private - returns (F3Ddatasets.EventReturns) - { - // setup local rID - uint256 _RID = rID_; - - // grab our winning player and team id's - uint256 _winPID = round_[_RID].plyr; - uint256 _winTID = round_[_RID].team; - - // grab our pot amount - uint256 _pot = round_[_RID].pot; - - // calculate our winner share, community rewards, gen share, - // p3d share, and amount reserved for next pot - uint256 _win = (_pot.mul(48)) / 100; - uint256 _com = (_pot / 20); - uint256 _gen = (_pot.mul(potSplit_[_winTID].gen)) / 100; - uint256 _p3d = (_pot.mul(potSplit_[_winTID].p3d)) / 100; - uint256 _res = (((_pot.sub(_win)).sub(_com)).sub(_gen)).sub(_p3d); - - // calculate ppt for round mask - uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_RID].keys); - uint256 _dust = _gen.sub((_ppt.mul(round_[_RID].keys)) / 1000000000000000000); - if (_dust > 0) - { - _gen = _gen.sub(_dust); - _res = _res.add(_dust); - } - - // pay our winner - plyr_[_winPID].win = _win.add(plyr_[_winPID].win); - - // community rewards - - TEAMWALLET.transfer(_com); - - // if (!address(Jekyll_Island_Inc).call.value(_com)(bytes4(keccak256("deposit()")))) - // { - // // This ensures Team Just cannot influence the outcome of FoMo3D with - // // bank migrations by breaking outgoing transactions. - // // Something we would never do. But that's not the point. - // // We spent 2000$ in eth re-deploying just to patch this, we hold the - // // highest belief that everything we create should be trustless. - // // Team JUST, The name you shouldn't have to trust. - // _p3d = _p3d.add(_com); - // _com = 0; - // } - - // distribute gen portion to key holders - round_[_RID].mask = _ppt.add(round_[_RID].mask); - - // send share for p3d to divies - // if (_p3d > 0) - // Divies.deposit.value(_p3d)(); - - // prepare event data - _EventData_.compressedData = _EventData_.compressedData + (round_[_RID].end * 1000000); - _EventData_.compressedIDs = _EventData_.compressedIDs + (_winPID * 100000000000000000000000000) + (_winTID * 100000000000000000); - _EventData_.winnerAddr = plyr_[_winPID].addr; - _EventData_.winnerName = plyr_[_winPID].name; - _EventData_.amountWon = _win; - _EventData_.genAmount = _gen; - _EventData_.P3DAmount = _p3d; - _EventData_.newPot = _res; - - // start next round - rID_++; - _RID++; - round_[_RID].strt = now; - round_[_RID].end = now.add(RNDINIT_).add(RNDGAP_); - round_[_RID].pot = _res; - - return(_EventData_); - } - - /** - * @dev moves any unmasked earnings to gen vault. updates earnings mask - */ - function updateGenVault(uint256 _PID, uint256 _RIDlast) - private - { - uint256 _earnings = calcUnMaskedEarnings(_PID, _RIDlast); - if (_earnings > 0) - { - // put in gen vault - plyr_[_PID].gen = _earnings.add(plyr_[_PID].gen); - // zero out their earnings by updating mask - plyrRnds_[_PID][_RIDlast].mask = _earnings.add(plyrRnds_[_PID][_RIDlast].mask); - } - } - - /** - * @dev updates round timer based on number of whole keys bought. - */ - function updateTimer(uint256 _Keys, uint256 _RID) - private - { - // grab time - uint256 _now = now; - - // calculate time based on number of keys bought - uint256 _newTime; - if (_now > round_[_RID].end && round_[_RID].plyr == 0) - _newTime = (((_Keys) / (1000000000000000000)).mul(RNDINC_)).add(_now); - else - _newTime = (((_Keys) / (1000000000000000000)).mul(RNDINC_)).add(round_[_RID].end); - - // compare to max and set new end time - if (_newTime < (RNDMAX_).add(_now)) - round_[_RID].end = _newTime; - else - round_[_RID].end = RNDMAX_.add(_now); - } - - /** - * @dev generates a random number between 0-99 and checks to see if thats - * resulted in an airdrop win - * @return do we have a winner? - */ - function airdrop() - private - view - returns(bool) - { - uint256 seed = uint256(keccak256(abi.encodePacked( - - (block.timestamp).add - (block.difficulty).add - ((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add - (block.gaslimit).add - ((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add - (block.number) - - ))); - if((seed - ((seed / 1000) * 1000)) < airDropTracker_) - return(true); - else - return(false); - } - - /** - * @dev distributes eth based on fees to com, aff, and p3d - */ - function distributeExternal(uint256 _RID, uint256 _PID, uint256 _Eth, uint256 _AffID, uint256 _Team, F3Ddatasets.EventReturns memory _EventData_) - private - returns(F3Ddatasets.EventReturns) - { - // pay 10% out to community rewards - uint256 _com = _Eth / 10; - //uint256 _p3d; - - TEAMWALLET.transfer(_com); - // if (!address(Jekyll_Island_Inc).call.value(_com)(bytes4(keccak256("deposit()")))) - // { - // // This ensures Team Just cannot influence the outcome of FoMo3D with - // // bank migrations by breaking outgoing transactions. - // // Something we would never do. But that's not the point. - // // We spent 2000$ in eth re-deploying just to patch this, we hold the - // // highest belief that everything we create should be trustless. - // // Team JUST, The name you shouldn't have to trust. - // _p3d = _com; - // _com = 0; - // } - - // pay 1% out to FoMo3D short - uint256 _leader = _Eth / 20; - //otherF3D_.potSwap.value(_long)(); - - // distribute share to affiliate - uint256 _aff = _Eth / 10; - - // decide what to do with affiliate share of fees - // affiliate must not be self, and must have a name registered - if (_AffID != _PID && plyr_[_AffID].name != '') { - plyr_[_AffID].aff = _aff.add(plyr_[_AffID].aff); - emit F3Devents.OnAffiliatePayout(_AffID, plyr_[_AffID].addr, plyr_[_AffID].name, _RID, _PID, _aff, now); - } else { - _leader =_leader.add(_aff); - } - - leaderWallets[_Team].transfer(_leader); - - // pay out p3d - // _p3d = _p3d.add((_eth.mul(fees_[_Team].p3d)) / (100)); - // if (_p3d > 0) - // { - // // deposit to divies contract - // Divies.deposit.value(_p3d)(); - - // // set up event data - // _eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount); - // } - - return(_EventData_); - } - - function potSwap() - external - payable - { - // setup local rID - uint256 _RID = rID_ + 1; - - round_[_RID].pot = round_[_RID].pot.add(msg.value); - emit F3Devents.OnPotSwapDeposit(_RID, msg.value); - } - - /** - * @dev distributes eth based on fees to gen and pot - */ - function distributeInternal(uint256 _RID, uint256 _PID, uint256 _Eth, uint256 _Team, uint256 _Keys, F3Ddatasets.EventReturns memory _EventData_) - private - returns(F3Ddatasets.EventReturns) - { - // calculate gen share - uint256 _gen = (_Eth.mul(fees_[_Team].gen)) / 100; - - // toss 1% into airdrop pot - uint256 _air = (_Eth / 100); - airDropPot_ = airDropPot_.add(_air); - - // update eth balance (eth = eth - (com share + pot swap share + aff share + p3d share + airdrop pot share)) - _Eth = _Eth.sub(((_Eth.mul(26)) / 100).add((_Eth.mul(fees_[_Team].p3d)) / 100)); - - // calculate pot - uint256 _pot = _Eth.sub(_gen); - - // distribute gen share (thats what updateMasks() does) and adjust - // balances for dust. - uint256 _dust = updateMasks(_RID, _PID, _gen, _Keys); - if (_dust > 0) - _gen = _gen.sub(_dust); - - // add eth to pot - round_[_RID].pot = _pot.add(_dust).add(round_[_RID].pot); - - // set up event data - _EventData_.genAmount = _gen.add(_EventData_.genAmount); - _EventData_.potAmount = _pot; - - return(_EventData_); - } - - /** - * @dev updates masks for round and player when keys are bought - * @return dust left over - */ - function updateMasks(uint256 _RID, uint256 _PID, uint256 _Gen, uint256 _Keys) - private - returns(uint256) - { - /* MASKING NOTES - earnings masks are a tricky thing for people to wrap their minds around. - the basic thing to understand here. is were going to have a global - tracker based on profit per share for each round, that increases in - relevant proportion to the increase in share supply. - - the player will have an additional mask that basically says "based - on the rounds mask, my shares, and how much i've already withdrawn, - how much is still owed to me?" - */ - - // calc profit per key & round mask based on this buy: (dust goes to pot) - uint256 _ppt = (_Gen.mul(1000000000000000000)) / (round_[_RID].keys); - round_[_RID].mask = _ppt.add(round_[_RID].mask); - - // calculate player earning from their own buy (only based on the keys - // they just bought). & update player earnings mask - uint256 _pearn = (_ppt.mul(_Keys)) / (1000000000000000000); - plyrRnds_[_PID][_RID].mask = (((round_[_RID].mask.mul(_Keys)) / (1000000000000000000)).sub(_pearn)).add(plyrRnds_[_PID][_RID].mask); - - // calculate & return dust - return(_Gen.sub((_ppt.mul(round_[_RID].keys)) / (1000000000000000000))); - } - - /** - * @dev adds up unmasked earnings, & vault earnings, sets them all to 0 - * @return earnings in wei format - */ - function withdrawEarnings(uint256 _PID) - private - returns(uint256) - { - // update gen vault - updateGenVault(_PID, plyr_[_PID].lrnd); - - // from vaults - uint256 _earnings = (plyr_[_PID].win).add(plyr_[_PID].gen).add(plyr_[_PID].aff); - if (_earnings > 0) - { - plyr_[_PID].win = 0; - plyr_[_PID].gen = 0; - plyr_[_PID].aff = 0; - } - - return(_earnings); - } - - /** - * @dev prepares compression data and fires event for buy or reload tx's - */ - function endTx(uint256 _PID, uint256 _Team, uint256 _Eth, uint256 _Keys, F3Ddatasets.EventReturns memory _EventData_) - private - { - _EventData_.compressedData = _EventData_.compressedData + (now * 1000000000000000000) + (_Team * 100000000000000000000000000000); - _EventData_.compressedIDs = _EventData_.compressedIDs + _PID + (rID_ * 10000000000000000000000000000000000000000000000000000); - - emit F3Devents.OnEndTx - ( - _EventData_.compressedData, - _EventData_.compressedIDs, - plyr_[_PID].name, - msg.sender, - _Eth, - _Keys, - _EventData_.winnerAddr, - _EventData_.winnerName, - _EventData_.amountWon, - _EventData_.newPot, - _EventData_.P3DAmount, - _EventData_.genAmount, - _EventData_.potAmount, - airDropPot_ - ); - } -//============================================================================== -// (~ _ _ _._|_ . -// _)(/_(_|_|| | | \/ . -//====================/========================================================= - /** upon contract deploy, it will be deactivated. this is a one time - * use function that will activate the contract. we do this so devs - * have time to set things up on the web end **/ - bool public activated_ = false; - function activate() - onlyDevs() - external - { - // make sure that its been linked. - // can only be ran once - require(activated_ == false, "fomo3d already activated"); - - // activate the contract - activated_ = true; - - // lets start first round - rID_ = 1; - round_[1].strt = now + RNDEXTRA_ - RNDGAP_; - round_[1].end = now + RNDINIT_ + RNDEXTRA_; - } -} diff --git a/slither/tools/slither_format/tests/real_world/0xbf45f4280cfbe7c2d2515a7d984b8c71c15e82b7_EnclavesDEXProxy.sol b/slither/tools/slither_format/tests/real_world/0xbf45f4280cfbe7c2d2515a7d984b8c71c15e82b7_EnclavesDEXProxy.sol deleted file mode 100644 index 4afe40fec..000000000 --- a/slither/tools/slither_format/tests/real_world/0xbf45f4280cfbe7c2d2515a7d984b8c71c15e82b7_EnclavesDEXProxy.sol +++ /dev/null @@ -1,286 +0,0 @@ -pragma solidity ^0.4.18; - -// File: contracts/EtherDeltaI.sol - -contract EtherDeltaI { - - uint public feeMake; //percentage times (1 ether) - uint public feeTake; //percentage times (1 ether) - - mapping (address => mapping (address => uint)) public tokens; //mapping of token addresses to mapping of account balances (token=0 means Ether) - mapping (address => mapping (bytes32 => bool)) public orders; //mapping of user accounts to mapping of order hashes to booleans (true = submitted by user, equivalent to offchain signature) - mapping (address => mapping (bytes32 => uint)) public orderFills; //mapping of user accounts to mapping of order hashes to uints (amount of order that has been filled) - - function deposit() payable; - - function withdraw(uint amount); - - function depositToken(address token, uint amount); - - function withdrawToken(address token, uint amount); - - function balanceOf(address token, address user) constant returns (uint); - - function order(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce); - - function trade(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce, address user, uint8 v, bytes32 r, bytes32 s, uint amount); - - function testTrade(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce, address user, uint8 v, bytes32 r, bytes32 s, uint amount, address sender) constant returns(bool); - - function availableVolume(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce, address user, uint8 v, bytes32 r, bytes32 s) constant returns(uint); - - function amountFilled(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce, address user, uint8 v, bytes32 r, bytes32 s) constant returns(uint); - - function cancelOrder(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce, uint8 v, bytes32 r, bytes32 s); - -} - -// File: contracts/KindMath.sol - -/** - * @title KindMath - * @dev Math operations with safety checks that fail - */ -library KindMath { - function mul(uint256 a, uint256 b) internal pure returns (uint256) { - uint256 c = a * b; - require(a == 0 || c / a == b); - return c; - } - - function div(uint256 a, uint256 b) internal pure returns (uint256) { - // assert(b > 0); // Solidity automatically throws when dividing by 0 - uint256 c = a / b; - // assert(a == b * c + a % b); // There is no case in which this doesn't hold - return c; - } - - function sub(uint256 a, uint256 b) internal pure returns (uint256) { - require(b <= a); - return a - b; - } - - function add(uint256 a, uint256 b) internal pure returns (uint256) { - uint256 c = a + b; - require(c >= a); - return c; - } -} - -// File: contracts/KeyValueStorage.sol - -contract KeyValueStorage { - - mapping(address => mapping(bytes32 => uint256)) _uintStorage; - mapping(address => mapping(bytes32 => address)) _addressStorage; - mapping(address => mapping(bytes32 => bool)) _boolStorage; - mapping(address => mapping(bytes32 => bytes32)) _bytes32Storage; - - /**** Get Methods ***********/ - - function getAddress(bytes32 key) public view returns (address) { - return _addressStorage[msg.sender][key]; - } - - function getUint(bytes32 key) public view returns (uint) { - return _uintStorage[msg.sender][key]; - } - - function getBool(bytes32 key) public view returns (bool) { - return _boolStorage[msg.sender][key]; - } - - function getBytes32(bytes32 key) public view returns (bytes32) { - return _bytes32Storage[msg.sender][key]; - } - - /**** Set Methods ***********/ - - function setAddress(bytes32 key, address value) public { - _addressStorage[msg.sender][key] = value; - } - - function setUint(bytes32 key, uint value) public { - _uintStorage[msg.sender][key] = value; - } - - function setBool(bytes32 key, bool value) public { - _boolStorage[msg.sender][key] = value; - } - - function setBytes32(bytes32 key, bytes32 value) public { - _bytes32Storage[msg.sender][key] = value; - } - - /**** Delete Methods ***********/ - - function deleteAddress(bytes32 key) public { - delete _addressStorage[msg.sender][key]; - } - - function deleteUint(bytes32 key) public { - delete _uintStorage[msg.sender][key]; - } - - function deleteBool(bytes32 key) public { - delete _boolStorage[msg.sender][key]; - } - - function deleteBytes32(bytes32 key) public { - delete _bytes32Storage[msg.sender][key]; - } - -} - -// File: contracts/StorageStateful.sol - -contract StorageStateful { - KeyValueStorage public keyValueStorage; -} - -// File: contracts/StorageConsumer.sol - -contract StorageConsumer is StorageStateful { - function StorageConsumer(address _storageAddress) public { - require(_storageAddress != address(0)); - keyValueStorage = KeyValueStorage(_storageAddress); - } -} - -// File: contracts/TokenI.sol - -contract Token { - /// @return total amount of tokens - function totalSupply() public returns (uint256); - - /// @param _owner The address from which the balance will be retrieved - /// @return The balance - function balanceOf(address _owner) public returns (uint256); - - /// @notice send `_value` token to `_to` from `msg.sender` - /// @param _to The address of the recipient - /// @param _value The amount of token to be transferred - /// @return Whether the transfer was successful or not - function transfer(address _to, uint256 _value) public returns (bool); - - /// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from` - /// @param _from The address of the sender - /// @param _to The address of the recipient - /// @param _value The amount of token to be transferred - /// @return Whether the transfer was successful or not - function transferFrom(address _from, address _to, uint256 _value) public returns (bool); - - /// @notice `msg.sender` approves `_addr` to spend `_value` tokens - /// @param _spender The address of the account able to transfer the tokens - /// @param _value The amount of wei to be approved for transfer - /// @return Whether the approval was successful or not - function approve(address _spender, uint256 _value) public returns (bool); - - /// @param _owner The address of the account owning tokens - /// @param _spender The address of the account able to transfer the tokens - /// @return Amount of remaining tokens allowed to spent - function allowance(address _owner, address _spender) public returns (uint256); - - event Transfer(address indexed _from, address indexed _to, uint256 _value); - event Approval(address indexed _owner, address indexed _spender, uint256 _value); - - uint256 public decimals; - string public name; -} - -// File: contracts/EnclavesDEXProxy.sol - -contract EnclavesDEXProxy is StorageConsumer { - using KindMath for uint256; - - address public admin; //the admin address - address public feeAccount; //the account that will receive fees - - struct EtherDeltaInfo { - uint256 feeMake; - uint256 feeTake; - } - - EtherDeltaInfo public etherDeltaInfo; - - uint256 public feeTake; //percentage times 1 ether - uint256 public feeAmountThreshold; //gasPrice amount under which no fees are charged - - address public etherDelta; - - bool public useEIP712 = true; - bytes32 public tradeABIHash; - bytes32 public withdrawABIHash; - - bool freezeTrading; - bool depositTokenLock; - - mapping (address => mapping (uint256 => bool)) nonceCheck; - - mapping (address => mapping (address => uint256)) public tokens; //mapping of token addresses to mapping of account balances (token=0 means Ether) - mapping (address => mapping (bytes32 => bool)) public orders; //mapping of user accounts to mapping of order hashes to booleans (true = submitted by user, equivalent to offchain signature) - mapping (address => mapping (bytes32 => uint256)) public orderFills; //mapping of user accounts to mapping of order hashes to uints (amount of order that has been filled) - - address internal implementation; - address public proposedImplementation; - uint256 public proposedTimestamp; - - event Upgraded(address _implementation); - event UpgradedProposed(address _proposedImplementation, uint256 _proposedTimestamp); - - modifier onlyAdmin { - require(msg.sender == admin); - _; - } - - function EnclavesDEXProxy(address _storageAddress, address _implementation, address _admin, address _feeAccount, uint256 _feeTake, uint256 _feeAmountThreshold, address _etherDelta, bytes32 _tradeABIHash, bytes32 _withdrawABIHash) public - StorageConsumer(_storageAddress) - { - require(_implementation != address(0)); - implementation = _implementation; - admin = _admin; - feeAccount = _feeAccount; - feeTake = _feeTake; - feeAmountThreshold = _feeAmountThreshold; - etherDelta = _etherDelta; - tradeABIHash = _tradeABIHash; - withdrawABIHash = _withdrawABIHash; - etherDeltaInfo.feeMake = EtherDeltaI(etherDelta).feeMake(); - etherDeltaInfo.feeTake = EtherDeltaI(etherDelta).feeTake(); - } - - function getImplementation() public view returns(address) { - return implementation; - } - - function proposeUpgrade(address _proposedImplementation) public onlyAdmin { - require(implementation != _proposedImplementation); - require(_proposedImplementation != address(0)); - proposedImplementation = _proposedImplementation; - proposedTimestamp = now + 2 weeks; - UpgradedProposed(proposedImplementation, now); - } - - function upgrade() public onlyAdmin { - require(proposedImplementation != address(0)); - require(proposedTimestamp < now); - implementation = proposedImplementation; - Upgraded(implementation); - } - - function () payable public { - bytes memory data = msg.data; - address impl = getImplementation(); - - assembly { - let result := delegatecall(gas, impl, add(data, 0x20), mload(data), 0, 0) - let size := returndatasize - let ptr := mload(0x40) - returndatacopy(ptr, 0, size) - switch result - case 0 { revert(ptr, size) } - default { return(ptr, size) } - } - } - -} \ No newline at end of file diff --git a/slither/tools/slither_format/tests/real_world/0xc6725ae749677f21e4d8f85f41cfb6de49b9db29_BancorConverter.sol b/slither/tools/slither_format/tests/real_world/0xc6725ae749677f21e4d8f85f41cfb6de49b9db29_BancorConverter.sol deleted file mode 100644 index d69f55f04..000000000 --- a/slither/tools/slither_format/tests/real_world/0xc6725ae749677f21e4d8f85f41cfb6de49b9db29_BancorConverter.sol +++ /dev/null @@ -1,1011 +0,0 @@ -pragma solidity ^0.4.18; - -/* - Utilities & Common Modifiers -*/ -contract Utils { - /** - constructor - */ - function Utils() public { - } - - // verifies that an amount is greater than zero - modifier greaterThanZero(uint256 _amount) { - require(_amount > 0); - _; - } - - // validates an address - currently only checks that it isn't null - modifier validAddress(address _address) { - require(_address != address(0)); - _; - } - - // verifies that the address is different than this contract address - modifier notThis(address _address) { - require(_address != address(this)); - _; - } - - // Overflow protected math functions - - /** - @dev returns the sum of _x and _y, asserts if the calculation overflows - - @param _x value 1 - @param _y value 2 - - @return sum - */ - function safeAdd(uint256 _x, uint256 _y) internal pure returns (uint256) { - uint256 z = _x + _y; - assert(z >= _x); - return z; - } - - /** - @dev returns the difference of _x minus _y, asserts if the subtraction results in a negative number - - @param _x minuend - @param _y subtrahend - - @return difference - */ - function safeSub(uint256 _x, uint256 _y) internal pure returns (uint256) { - assert(_x >= _y); - return _x - _y; - } - - /** - @dev returns the product of multiplying _x by _y, asserts if the calculation overflows - - @param _x factor 1 - @param _y factor 2 - - @return product - */ - function safeMul(uint256 _x, uint256 _y) internal pure returns (uint256) { - uint256 z = _x * _y; - assert(_x == 0 || z / _x == _y); - return z; - } -} - -/* - Owned contract interface -*/ -contract IOwned { - // this function isn't abstract since the compiler emits automatically generated getter functions as external - function owner() public view returns (address) {} - - function transferOwnership(address _newOwner) public; - function acceptOwnership() public; -} - -/* - Provides support and utilities for contract ownership -*/ -contract Owned is IOwned { - address public owner; - address public newOwner; - - event OwnerUpdate(address indexed _prevOwner, address indexed _newOwner); - - /** - @dev constructor - */ - function Owned() public { - owner = msg.sender; - } - - // allows execution by the owner only - modifier ownerOnly { - assert(msg.sender == owner); - _; - } - - /** - @dev allows transferring the contract ownership - the new owner still needs to accept the transfer - can only be called by the contract owner - - @param _newOwner new contract owner - */ - function transferOwnership(address _newOwner) public ownerOnly { - require(_newOwner != owner); - newOwner = _newOwner; - } - - /** - @dev used by a new owner to accept an ownership transfer - */ - function acceptOwnership() public { - require(msg.sender == newOwner); - OwnerUpdate(owner, newOwner); - owner = newOwner; - newOwner = address(0); - } -} - -/* - Provides support and utilities for contract management -*/ -contract Managed { - address public manager; - address public newManager; - - event ManagerUpdate(address indexed _prevManager, address indexed _newManager); - - /** - @dev constructor - */ - function Managed() public { - manager = msg.sender; - } - - // allows execution by the manager only - modifier managerOnly { - assert(msg.sender == manager); - _; - } - - /** - @dev allows transferring the contract management - the new manager still needs to accept the transfer - can only be called by the contract manager - - @param _newManager new contract manager - */ - function transferManagement(address _newManager) public managerOnly { - require(_newManager != manager); - newManager = _newManager; - } - - /** - @dev used by a new manager to accept a management transfer - */ - function acceptManagement() public { - require(msg.sender == newManager); - ManagerUpdate(manager, newManager); - manager = newManager; - newManager = address(0); - } -} - -/* - ERC20 Standard Token interface -*/ -contract IERC20Token { - // these functions aren't abstract since the compiler emits automatically generated getter functions as external - function name() public view returns (string) {} - function symbol() public view returns (string) {} - function decimals() public view returns (uint8) {} - function totalSupply() public view returns (uint256) {} - function balanceOf(address _owner) public view returns (uint256) { _owner; } - function allowance(address _owner, address _spender) public view returns (uint256) { _owner; _spender; } - - function transfer(address _to, uint256 _value) public returns (bool success); - function transferFrom(address _from, address _to, uint256 _value) public returns (bool success); - function approve(address _spender, uint256 _value) public returns (bool success); -} - -/* - Smart Token interface -*/ -contract ISmartToken is IOwned, IERC20Token { - function disableTransfers(bool _disable) public; - function issue(address _to, uint256 _amount) public; - function destroy(address _from, uint256 _amount) public; -} - -/* - Token Holder interface -*/ -contract ITokenHolder is IOwned { - function withdrawTokens(IERC20Token _token, address _to, uint256 _amount) public; -} - -/* - We consider every contract to be a 'token holder' since it's currently not possible - for a contract to deny receiving tokens. - - The TokenHolder's contract sole purpose is to provide a safety mechanism that allows - the owner to send tokens that were sent to the contract by mistake back to their sender. -*/ -contract TokenHolder is ITokenHolder, Owned, Utils { - /** - @dev constructor - */ - function TokenHolder() public { - } - - /** - @dev withdraws tokens held by the contract and sends them to an account - can only be called by the owner - - @param _token ERC20 token contract address - @param _to account to receive the new amount - @param _amount amount to withdraw - */ - function withdrawTokens(IERC20Token _token, address _to, uint256 _amount) - public - ownerOnly - validAddress(_token) - validAddress(_to) - notThis(_to) - { - assert(_token.transfer(_to, _amount)); - } -} - -/* - The smart token controller is an upgradable part of the smart token that allows - more functionality as well as fixes for bugs/exploits. - Once it accepts ownership of the token, it becomes the token's sole controller - that can execute any of its functions. - - To upgrade the controller, ownership must be transferred to a new controller, along with - any relevant data. - - The smart token must be set on construction and cannot be changed afterwards. - Wrappers are provided (as opposed to a single 'execute' function) for each of the token's functions, for easier access. - - Note that the controller can transfer token ownership to a new controller that - doesn't allow executing any function on the token, for a trustless solution. - Doing that will also remove the owner's ability to upgrade the controller. -*/ -contract SmartTokenController is TokenHolder { - ISmartToken public token; // smart token - - /** - @dev constructor - */ - function SmartTokenController(ISmartToken _token) - public - validAddress(_token) - { - token = _token; - } - - // ensures that the controller is the token's owner - modifier active() { - assert(token.owner() == address(this)); - _; - } - - // ensures that the controller is not the token's owner - modifier inactive() { - assert(token.owner() != address(this)); - _; - } - - /** - @dev allows transferring the token ownership - the new owner still need to accept the transfer - can only be called by the contract owner - - @param _newOwner new token owner - */ - function transferTokenOwnership(address _newOwner) public ownerOnly { - token.transferOwnership(_newOwner); - } - - /** - @dev used by a new owner to accept a token ownership transfer - can only be called by the contract owner - */ - function acceptTokenOwnership() public ownerOnly { - token.acceptOwnership(); - } - - /** - @dev disables/enables token transfers - can only be called by the contract owner - - @param _disable true to disable transfers, false to enable them - */ - function disableTokenTransfers(bool _disable) public ownerOnly { - token.disableTransfers(_disable); - } - - /** - @dev withdraws tokens held by the controller and sends them to an account - can only be called by the owner - - @param _token ERC20 token contract address - @param _to account to receive the new amount - @param _amount amount to withdraw - */ - function withdrawFromToken( - IERC20Token _token, - address _to, - uint256 _amount - ) - public - ownerOnly - { - ITokenHolder(token).withdrawTokens(_token, _to, _amount); - } -} - -/* - Bancor Formula interface -*/ -contract IBancorFormula { - function calculatePurchaseReturn(uint256 _supply, uint256 _connectorBalance, uint32 _connectorWeight, uint256 _depositAmount) public view returns (uint256); - function calculateSaleReturn(uint256 _supply, uint256 _connectorBalance, uint32 _connectorWeight, uint256 _sellAmount) public view returns (uint256); - function calculateCrossConnectorReturn(uint256 _connector1Balance, uint32 _connector1Weight, uint256 _connector2Balance, uint32 _connector2Weight, uint256 _amount) public view returns (uint256); -} - -/* - Bancor Gas Price Limit interface -*/ -contract IBancorGasPriceLimit { - function gasPrice() public view returns (uint256) {} - function validateGasPrice(uint256) public view; -} - -/* - Bancor Quick Converter interface -*/ -contract IBancorQuickConverter { - function convert(IERC20Token[] _path, uint256 _amount, uint256 _minReturn) public payable returns (uint256); - function convertFor(IERC20Token[] _path, uint256 _amount, uint256 _minReturn, address _for) public payable returns (uint256); - function convertForPrioritized(IERC20Token[] _path, uint256 _amount, uint256 _minReturn, address _for, uint256 _block, uint256 _nonce, uint8 _v, bytes32 _r, bytes32 _s) public payable returns (uint256); -} - -/* - Bancor Converter Extensions interface -*/ -contract IBancorConverterExtensions { - function formula() public view returns (IBancorFormula) {} - function gasPriceLimit() public view returns (IBancorGasPriceLimit) {} - function quickConverter() public view returns (IBancorQuickConverter) {} -} - -/* - EIP228 Token Converter interface -*/ -contract ITokenConverter { - function convertibleTokenCount() public view returns (uint16); - function convertibleToken(uint16 _tokenIndex) public view returns (address); - function getReturn(IERC20Token _fromToken, IERC20Token _toToken, uint256 _amount) public view returns (uint256); - function convert(IERC20Token _fromToken, IERC20Token _toToken, uint256 _amount, uint256 _minReturn) public returns (uint256); - // deprecated, backward compatibility - function change(IERC20Token _fromToken, IERC20Token _toToken, uint256 _amount, uint256 _minReturn) public returns (uint256); -} - -/* - Bancor Converter v0.8 - - The Bancor version of the token converter, allows conversion between a smart token and other ERC20 tokens and between different ERC20 tokens and themselves. - - ERC20 connector balance can be virtual, meaning that the calculations are based on the virtual balance instead of relying on - the actual connector balance. This is a security mechanism that prevents the need to keep a very large (and valuable) balance in a single contract. - - The converter is upgradable (just like any SmartTokenController). - - WARNING: It is NOT RECOMMENDED to use the converter with Smart Tokens that have less than 8 decimal digits - or with very small numbers because of precision loss - - - Open issues: - - Front-running attacks are currently mitigated by the following mechanisms: - - minimum return argument for each conversion provides a way to define a minimum/maximum price for the transaction - - gas price limit prevents users from having control over the order of execution - Other potential solutions might include a commit/reveal based schemes - - Possibly add getters for the connector fields so that the client won't need to rely on the order in the struct -*/ -contract BancorConverter is ITokenConverter, SmartTokenController, Managed { - uint32 private constant MAX_WEIGHT = 1000000; - uint32 private constant MAX_CONVERSION_FEE = 1000000; - - struct Connector { - uint256 virtualBalance; // connector virtual balance - uint32 weight; // connector weight, represented in ppm, 1-1000000 - bool isVirtualBalanceEnabled; // true if virtual balance is enabled, false if not - bool isPurchaseEnabled; // is purchase of the smart token enabled with the connector, can be set by the owner - bool isSet; // used to tell if the mapping element is defined - } - - string public version = '0.8'; - string public converterType = 'bancor'; - - IBancorConverterExtensions public extensions; // bancor converter extensions contract - IERC20Token[] public connectorTokens; // ERC20 standard token addresses - IERC20Token[] public quickBuyPath; // conversion path that's used in order to buy the token with ETH - mapping (address => Connector) public connectors; // connector token addresses -> connector data - uint32 private totalConnectorWeight = 0; // used to efficiently prevent increasing the total connector weight above 100% - uint32 public maxConversionFee = 0; // maximum conversion fee for the lifetime of the contract, represented in ppm, 0...1000000 (0 = no fee, 100 = 0.01%, 1000000 = 100%) - uint32 public conversionFee = 0; // current conversion fee, represented in ppm, 0...maxConversionFee - bool public conversionsEnabled = true; // true if token conversions is enabled, false if not - IERC20Token[] private convertPath; - - // triggered when a conversion between two tokens occurs (TokenConverter event) - event Conversion(address indexed _fromToken, address indexed _toToken, address indexed _trader, uint256 _amount, uint256 _return, - int256 _conversionFee, uint256 _currentPriceN, uint256 _currentPriceD); - // triggered when the conversion fee is updated - event ConversionFeeUpdate(uint32 _prevFee, uint32 _newFee); - - /** - @dev constructor - - @param _token smart token governed by the converter - @param _extensions address of a bancor converter extensions contract - @param _maxConversionFee maximum conversion fee, represented in ppm - @param _connectorToken optional, initial connector, allows defining the first connector at deployment time - @param _connectorWeight optional, weight for the initial connector - */ - function BancorConverter(ISmartToken _token, IBancorConverterExtensions _extensions, uint32 _maxConversionFee, IERC20Token _connectorToken, uint32 _connectorWeight) - public - SmartTokenController(_token) - validAddress(_extensions) - validMaxConversionFee(_maxConversionFee) - { - extensions = _extensions; - maxConversionFee = _maxConversionFee; - - if (_connectorToken != address(0)) - addConnector(_connectorToken, _connectorWeight, false); - } - - // validates a connector token address - verifies that the address belongs to one of the connector tokens - modifier validConnector(IERC20Token _address) { - require(connectors[_address].isSet); - _; - } - - // validates a token address - verifies that the address belongs to one of the convertible tokens - modifier validToken(IERC20Token _address) { - require(_address == token || connectors[_address].isSet); - _; - } - - // validates maximum conversion fee - modifier validMaxConversionFee(uint32 _conversionFee) { - require(_conversionFee >= 0 && _conversionFee <= MAX_CONVERSION_FEE); - _; - } - - // validates conversion fee - modifier validConversionFee(uint32 _conversionFee) { - require(_conversionFee >= 0 && _conversionFee <= maxConversionFee); - _; - } - - // validates connector weight range - modifier validConnectorWeight(uint32 _weight) { - require(_weight > 0 && _weight <= MAX_WEIGHT); - _; - } - - // validates a conversion path - verifies that the number of elements is odd and that maximum number of 'hops' is 10 - modifier validConversionPath(IERC20Token[] _path) { - require(_path.length > 2 && _path.length <= (1 + 2 * 10) && _path.length % 2 == 1); - _; - } - - // allows execution only when conversions aren't disabled - modifier conversionsAllowed { - assert(conversionsEnabled); - _; - } - - // allows execution only for owner or manager - modifier ownerOrManagerOnly { - require(msg.sender == owner || msg.sender == manager); - _; - } - - // allows execution only for quick convreter - modifier quickConverterOnly { - require(msg.sender == address(extensions.quickConverter())); - _; - } - - /** - @dev returns the number of connector tokens defined - - @return number of connector tokens - */ - function connectorTokenCount() public view returns (uint16) { - return uint16(connectorTokens.length); - } - - /** - @dev returns the number of convertible tokens supported by the contract - note that the number of convertible tokens is the number of connector token, plus 1 (that represents the smart token) - - @return number of convertible tokens - */ - function convertibleTokenCount() public view returns (uint16) { - return connectorTokenCount() + 1; - } - - /** - @dev given a convertible token index, returns its contract address - - @param _tokenIndex convertible token index - - @return convertible token address - */ - function convertibleToken(uint16 _tokenIndex) public view returns (address) { - if (_tokenIndex == 0) - return token; - return connectorTokens[_tokenIndex - 1]; - } - - /* - @dev allows the owner to update the extensions contract address - - @param _extensions address of a bancor converter extensions contract - */ - function setExtensions(IBancorConverterExtensions _extensions) - public - ownerOnly - validAddress(_extensions) - notThis(_extensions) - { - extensions = _extensions; - } - - /* - @dev allows the manager to update the quick buy path - - @param _path new quick buy path, see conversion path format in the BancorQuickConverter contract - */ - function setQuickBuyPath(IERC20Token[] _path) - public - ownerOnly - validConversionPath(_path) - { - quickBuyPath = _path; - } - - /* - @dev allows the manager to clear the quick buy path - */ - function clearQuickBuyPath() public ownerOnly { - quickBuyPath.length = 0; - } - - /** - @dev returns the length of the quick buy path array - - @return quick buy path length - */ - function getQuickBuyPathLength() public view returns (uint256) { - return quickBuyPath.length; - } - - /** - @dev disables the entire conversion functionality - this is a safety mechanism in case of a emergency - can only be called by the manager - - @param _disable true to disable conversions, false to re-enable them - */ - function disableConversions(bool _disable) public ownerOrManagerOnly { - conversionsEnabled = !_disable; - } - - /** - @dev updates the current conversion fee - can only be called by the manager - - @param _conversionFee new conversion fee, represented in ppm - */ - function setConversionFee(uint32 _conversionFee) - public - ownerOrManagerOnly - validConversionFee(_conversionFee) - { - ConversionFeeUpdate(conversionFee, _conversionFee); - conversionFee = _conversionFee; - } - - /* - @dev returns the conversion fee amount for a given return amount - - @return conversion fee amount - */ - function getConversionFeeAmount(uint256 _amount) public view returns (uint256) { - return safeMul(_amount, conversionFee) / MAX_CONVERSION_FEE; - } - - /** - @dev defines a new connector for the token - can only be called by the owner while the converter is inactive - - @param _token address of the connector token - @param _weight constant connector weight, represented in ppm, 1-1000000 - @param _enableVirtualBalance true to enable virtual balance for the connector, false to disable it - */ - function addConnector(IERC20Token _token, uint32 _weight, bool _enableVirtualBalance) - public - ownerOnly - inactive - validAddress(_token) - notThis(_token) - validConnectorWeight(_weight) - { - require(_token != token && !connectors[_token].isSet && totalConnectorWeight + _weight <= MAX_WEIGHT); // validate input - - connectors[_token].virtualBalance = 0; - connectors[_token].weight = _weight; - connectors[_token].isVirtualBalanceEnabled = _enableVirtualBalance; - connectors[_token].isPurchaseEnabled = true; - connectors[_token].isSet = true; - connectorTokens.push(_token); - totalConnectorWeight += _weight; - } - - /** - @dev updates one of the token connectors - can only be called by the owner - - @param _connectorToken address of the connector token - @param _weight constant connector weight, represented in ppm, 1-1000000 - @param _enableVirtualBalance true to enable virtual balance for the connector, false to disable it - @param _virtualBalance new connector's virtual balance - */ - function updateConnector(IERC20Token _connectorToken, uint32 _weight, bool _enableVirtualBalance, uint256 _virtualBalance) - public - ownerOnly - validConnector(_connectorToken) - validConnectorWeight(_weight) - { - Connector storage connector = connectors[_connectorToken]; - require(totalConnectorWeight - connector.weight + _weight <= MAX_WEIGHT); // validate input - - totalConnectorWeight = totalConnectorWeight - connector.weight + _weight; - connector.weight = _weight; - connector.isVirtualBalanceEnabled = _enableVirtualBalance; - connector.virtualBalance = _virtualBalance; - } - - /** - @dev disables purchasing with the given connector token in case the connector token got compromised - can only be called by the owner - note that selling is still enabled regardless of this flag and it cannot be disabled by the owner - - @param _connectorToken connector token contract address - @param _disable true to disable the token, false to re-enable it - */ - function disableConnectorPurchases(IERC20Token _connectorToken, bool _disable) - public - ownerOnly - validConnector(_connectorToken) - { - connectors[_connectorToken].isPurchaseEnabled = !_disable; - } - - /** - @dev returns the connector's virtual balance if one is defined, otherwise returns the actual balance - - @param _connectorToken connector token contract address - - @return connector balance - */ - function getConnectorBalance(IERC20Token _connectorToken) - public - view - validConnector(_connectorToken) - returns (uint256) - { - Connector storage connector = connectors[_connectorToken]; - return connector.isVirtualBalanceEnabled ? connector.virtualBalance : _connectorToken.balanceOf(this); - } - - /** - @dev returns the expected return for converting a specific amount of _fromToken to _toToken - - @param _fromToken ERC20 token to convert from - @param _toToken ERC20 token to convert to - @param _amount amount to convert, in fromToken - - @return expected conversion return amount - */ - function getReturn(IERC20Token _fromToken, IERC20Token _toToken, uint256 _amount) public view returns (uint256) { - require(_fromToken != _toToken); // validate input - - // conversion between the token and one of its connectors - if (_toToken == token) - return getPurchaseReturn(_fromToken, _amount); - else if (_fromToken == token) - return getSaleReturn(_toToken, _amount); - - // conversion between 2 connectors - uint256 purchaseReturnAmount = getPurchaseReturn(_fromToken, _amount); - return getSaleReturn(_toToken, purchaseReturnAmount, safeAdd(token.totalSupply(), purchaseReturnAmount)); - } - - /** - @dev returns the expected return for buying the token for a connector token - - @param _connectorToken connector token contract address - @param _depositAmount amount to deposit (in the connector token) - - @return expected purchase return amount - */ - function getPurchaseReturn(IERC20Token _connectorToken, uint256 _depositAmount) - public - view - active - validConnector(_connectorToken) - returns (uint256) - { - Connector storage connector = connectors[_connectorToken]; - require(connector.isPurchaseEnabled); // validate input - - uint256 tokenSupply = token.totalSupply(); - uint256 connectorBalance = getConnectorBalance(_connectorToken); - uint256 amount = extensions.formula().calculatePurchaseReturn(tokenSupply, connectorBalance, connector.weight, _depositAmount); - - // deduct the fee from the return amount - uint256 feeAmount = getConversionFeeAmount(amount); - return safeSub(amount, feeAmount); - } - - /** - @dev returns the expected return for selling the token for one of its connector tokens - - @param _connectorToken connector token contract address - @param _sellAmount amount to sell (in the smart token) - - @return expected sale return amount - */ - function getSaleReturn(IERC20Token _connectorToken, uint256 _sellAmount) public view returns (uint256) { - return getSaleReturn(_connectorToken, _sellAmount, token.totalSupply()); - } - - /** - @dev converts a specific amount of _fromToken to _toToken - - @param _fromToken ERC20 token to convert from - @param _toToken ERC20 token to convert to - @param _amount amount to convert, in fromToken - @param _minReturn if the conversion results in an amount smaller than the minimum return - it is cancelled, must be nonzero - - @return conversion return amount - */ - function convertInternal(IERC20Token _fromToken, IERC20Token _toToken, uint256 _amount, uint256 _minReturn) public quickConverterOnly returns (uint256) { - require(_fromToken != _toToken); // validate input - - // conversion between the token and one of its connectors - if (_toToken == token) - return buy(_fromToken, _amount, _minReturn); - else if (_fromToken == token) - return sell(_toToken, _amount, _minReturn); - - // conversion between 2 connectors - uint256 purchaseAmount = buy(_fromToken, _amount, 1); - return sell(_toToken, purchaseAmount, _minReturn); - } - - /** - @dev converts a specific amount of _fromToken to _toToken - - @param _fromToken ERC20 token to convert from - @param _toToken ERC20 token to convert to - @param _amount amount to convert, in fromToken - @param _minReturn if the conversion results in an amount smaller than the minimum return - it is cancelled, must be nonzero - - @return conversion return amount - */ - function convert(IERC20Token _fromToken, IERC20Token _toToken, uint256 _amount, uint256 _minReturn) public returns (uint256) { - convertPath = [_fromToken, token, _toToken]; - return quickConvert(convertPath, _amount, _minReturn); - } - - /** - @dev buys the token by depositing one of its connector tokens - - @param _connectorToken connector token contract address - @param _depositAmount amount to deposit (in the connector token) - @param _minReturn if the conversion results in an amount smaller than the minimum return - it is cancelled, must be nonzero - - @return buy return amount - */ - function buy(IERC20Token _connectorToken, uint256 _depositAmount, uint256 _minReturn) - internal - conversionsAllowed - greaterThanZero(_minReturn) - returns (uint256) - { - uint256 amount = getPurchaseReturn(_connectorToken, _depositAmount); - require(amount != 0 && amount >= _minReturn); // ensure the trade gives something in return and meets the minimum requested amount - - // update virtual balance if relevant - Connector storage connector = connectors[_connectorToken]; - if (connector.isVirtualBalanceEnabled) - connector.virtualBalance = safeAdd(connector.virtualBalance, _depositAmount); - - // transfer _depositAmount funds from the caller in the connector token - assert(_connectorToken.transferFrom(msg.sender, this, _depositAmount)); - // issue new funds to the caller in the smart token - token.issue(msg.sender, amount); - - dispatchConversionEvent(_connectorToken, _depositAmount, amount, true); - return amount; - } - - /** - @dev sells the token by withdrawing from one of its connector tokens - - @param _connectorToken connector token contract address - @param _sellAmount amount to sell (in the smart token) - @param _minReturn if the conversion results in an amount smaller the minimum return - it is cancelled, must be nonzero - - @return sell return amount - */ - function sell(IERC20Token _connectorToken, uint256 _sellAmount, uint256 _minReturn) - internal - conversionsAllowed - greaterThanZero(_minReturn) - returns (uint256) - { - require(_sellAmount <= token.balanceOf(msg.sender)); // validate input - - uint256 amount = getSaleReturn(_connectorToken, _sellAmount); - require(amount != 0 && amount >= _minReturn); // ensure the trade gives something in return and meets the minimum requested amount - - uint256 tokenSupply = token.totalSupply(); - uint256 connectorBalance = getConnectorBalance(_connectorToken); - // ensure that the trade will only deplete the connector if the total supply is depleted as well - assert(amount < connectorBalance || (amount == connectorBalance && _sellAmount == tokenSupply)); - - // update virtual balance if relevant - Connector storage connector = connectors[_connectorToken]; - if (connector.isVirtualBalanceEnabled) - connector.virtualBalance = safeSub(connector.virtualBalance, amount); - - // destroy _sellAmount from the caller's balance in the smart token - token.destroy(msg.sender, _sellAmount); - // transfer funds to the caller in the connector token - // the transfer might fail if the actual connector balance is smaller than the virtual balance - assert(_connectorToken.transfer(msg.sender, amount)); - - dispatchConversionEvent(_connectorToken, _sellAmount, amount, false); - return amount; - } - - /** - @dev converts the token to any other token in the bancor network by following a predefined conversion path - note that when converting from an ERC20 token (as opposed to a smart token), allowance must be set beforehand - - @param _path conversion path, see conversion path format in the BancorQuickConverter contract - @param _amount amount to convert from (in the initial source token) - @param _minReturn if the conversion results in an amount smaller than the minimum return - it is cancelled, must be nonzero - - @return tokens issued in return - */ - function quickConvert(IERC20Token[] _path, uint256 _amount, uint256 _minReturn) - public - payable - validConversionPath(_path) - returns (uint256) - { - return quickConvertPrioritized(_path, _amount, _minReturn, 0x0, 0x0, 0x0, 0x0, 0x0); - } - - /** - @dev converts the token to any other token in the bancor network by following a predefined conversion path - note that when converting from an ERC20 token (as opposed to a smart token), allowance must be set beforehand - - @param _path conversion path, see conversion path format in the BancorQuickConverter contract - @param _amount amount to convert from (in the initial source token) - @param _minReturn if the conversion results in an amount smaller than the minimum return - it is cancelled, must be nonzero - @param _block if the current block exceeded the given parameter - it is cancelled - @param _nonce the nonce of the sender address - @param _v parameter that can be parsed from the transaction signature - @param _r parameter that can be parsed from the transaction signature - @param _s parameter that can be parsed from the transaction signature - - @return tokens issued in return - */ - function quickConvertPrioritized(IERC20Token[] _path, uint256 _amount, uint256 _minReturn, uint256 _block, uint256 _nonce, uint8 _v, bytes32 _r, bytes32 _s) - public - payable - validConversionPath(_path) - returns (uint256) - { - IERC20Token fromToken = _path[0]; - IBancorQuickConverter quickConverter = extensions.quickConverter(); - - // we need to transfer the source tokens from the caller to the quick converter, - // so it can execute the conversion on behalf of the caller - if (msg.value == 0) { - // not ETH, send the source tokens to the quick converter - // if the token is the smart token, no allowance is required - destroy the tokens from the caller and issue them to the quick converter - if (fromToken == token) { - token.destroy(msg.sender, _amount); // destroy _amount tokens from the caller's balance in the smart token - token.issue(quickConverter, _amount); // issue _amount new tokens to the quick converter - } else { - // otherwise, we assume we already have allowance, transfer the tokens directly to the quick converter - assert(fromToken.transferFrom(msg.sender, quickConverter, _amount)); - } - } - - // execute the conversion and pass on the ETH with the call - return quickConverter.convertForPrioritized.value(msg.value)(_path, _amount, _minReturn, msg.sender, _block, _nonce, _v, _r, _s); - } - - // deprecated, backward compatibility - function change(IERC20Token _fromToken, IERC20Token _toToken, uint256 _amount, uint256 _minReturn) public returns (uint256) { - return convertInternal(_fromToken, _toToken, _amount, _minReturn); - } - - /** - @dev utility, returns the expected return for selling the token for one of its connector tokens, given a total supply override - - @param _connectorToken connector token contract address - @param _sellAmount amount to sell (in the smart token) - @param _totalSupply total token supply, overrides the actual token total supply when calculating the return - - @return sale return amount - */ - function getSaleReturn(IERC20Token _connectorToken, uint256 _sellAmount, uint256 _totalSupply) - private - view - active - validConnector(_connectorToken) - greaterThanZero(_totalSupply) - returns (uint256) - { - Connector storage connector = connectors[_connectorToken]; - uint256 connectorBalance = getConnectorBalance(_connectorToken); - uint256 amount = extensions.formula().calculateSaleReturn(_totalSupply, connectorBalance, connector.weight, _sellAmount); - - // deduct the fee from the return amount - uint256 feeAmount = getConversionFeeAmount(amount); - return safeSub(amount, feeAmount); - } - - /** - @dev helper, dispatches the Conversion event - The function also takes the tokens' decimals into account when calculating the current price - - @param _connectorToken connector token contract address - @param _amount amount purchased/sold (in the source token) - @param _returnAmount amount returned (in the target token) - @param isPurchase true if it's a purchase, false if it's a sale - */ - function dispatchConversionEvent(IERC20Token _connectorToken, uint256 _amount, uint256 _returnAmount, bool isPurchase) private { - Connector storage connector = connectors[_connectorToken]; - - // calculate the new price using the simple price formula - // price = connector balance / (supply * weight) - // weight is represented in ppm, so multiplying by 1000000 - uint256 connectorAmount = safeMul(getConnectorBalance(_connectorToken), MAX_WEIGHT); - uint256 tokenAmount = safeMul(token.totalSupply(), connector.weight); - - // normalize values - uint8 tokenDecimals = token.decimals(); - uint8 connectorTokenDecimals = _connectorToken.decimals(); - if (tokenDecimals != connectorTokenDecimals) { - if (tokenDecimals > connectorTokenDecimals) - connectorAmount = safeMul(connectorAmount, 10 ** uint256(tokenDecimals - connectorTokenDecimals)); - else - tokenAmount = safeMul(tokenAmount, 10 ** uint256(connectorTokenDecimals - tokenDecimals)); - } - - uint256 feeAmount = getConversionFeeAmount(_returnAmount); - // ensure that the fee is capped at 255 bits to prevent overflow when converting it to a signed int - assert(feeAmount <= 2 ** 255); - - if (isPurchase) - Conversion(_connectorToken, token, msg.sender, _amount, _returnAmount, int256(feeAmount), connectorAmount, tokenAmount); - else - Conversion(token, _connectorToken, msg.sender, _amount, _returnAmount, int256(feeAmount), tokenAmount, connectorAmount); - } - - /** - @dev fallback, buys the smart token with ETH - note that the purchase will use the price at the time of the purchase - */ - function() payable public { - quickConvert(quickBuyPath, msg.value, 1); - } -} \ No newline at end of file diff --git a/slither/tools/slither_format/tests/real_world/0xf5ed2dc77f0d1ea7f106ecbd1850e406adc41b51_OceanToken.sol b/slither/tools/slither_format/tests/real_world/0xf5ed2dc77f0d1ea7f106ecbd1850e406adc41b51_OceanToken.sol deleted file mode 100644 index 57830e096..000000000 --- a/slither/tools/slither_format/tests/real_world/0xf5ed2dc77f0d1ea7f106ecbd1850e406adc41b51_OceanToken.sol +++ /dev/null @@ -1,454 +0,0 @@ -pragma solidity ^0.4.18; - -/** - - Copyright (c) 2018 The Ocean. - - Licensed under the MIT License: https://opensource.org/licenses/MIT. - - Permission is hereby granted, free of charge, to any person obtaining - a copy of this software and associated documentation files (the - "Software"), to deal in the Software without restriction, including - without limitation the rights to use, copy, modify, merge, publish, - distribute, sublicense, and/or sell copies of the Software, and to - permit persons to whom the Software is furnished to do so, subject to - the following conditions: - - The above copyright notice and this permission notice shall be included - in all copies or substantial portions of the Software. - - THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS - OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF - MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. - IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY - CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, - TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE - SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. - -**/ - -/** - * @title Ownable - * @dev The Ownable contract has an owner address, and provides basic authorization control - * functions, this simplifies the implementation of "user permissions". - */ -contract Ownable { - address public owner; - - - event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); - - - /** - * @dev The Ownable constructor sets the original `owner` of the contract to the sender - * account. - */ - function Ownable() public { - owner = msg.sender; - } - - /** - * @dev Throws if called by any account other than the owner. - */ - modifier onlyOwner() { - require(msg.sender == owner); - _; - } - - /** - * @dev Allows the current owner to transfer control of the contract to a newOwner. - * @param newOwner The address to transfer ownership to. - */ - function transferOwnership(address newOwner) public onlyOwner { - require(newOwner != address(0)); - OwnershipTransferred(owner, newOwner); - owner = newOwner; - } - -} - - - -/** - * @title ERC20Basic - * @dev Simpler version of ERC20 interface - * @dev see https://github.com/ethereum/EIPs/issues/179 - */ -contract ERC20Basic { - function totalSupply() public view returns (uint256); - function balanceOf(address who) public view returns (uint256); - function transfer(address to, uint256 value) public returns (bool); - event Transfer(address indexed from, address indexed to, uint256 value); -} - - - - - - - - - - - -/** - * @title SafeMath - * @dev Math operations with safety checks that throw on error - */ -library SafeMath { - - /** - * @dev Multiplies two numbers, throws on overflow. - */ - function mul(uint256 a, uint256 b) internal pure returns (uint256) { - if (a == 0) { - return 0; - } - uint256 c = a * b; - assert(c / a == b); - return c; - } - - /** - * @dev Integer division of two numbers, truncating the quotient. - */ - function div(uint256 a, uint256 b) internal pure returns (uint256) { - // assert(b > 0); // Solidity automatically throws when dividing by 0 - uint256 c = a / b; - // assert(a == b * c + a % b); // There is no case in which this doesn't hold - return c; - } - - /** - * @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend). - */ - function sub(uint256 a, uint256 b) internal pure returns (uint256) { - assert(b <= a); - return a - b; - } - - /** - * @dev Adds two numbers, throws on overflow. - */ - function add(uint256 a, uint256 b) internal pure returns (uint256) { - uint256 c = a + b; - assert(c >= a); - return c; - } -} - - - -/** - * @title Basic token - * @dev Basic version of StandardToken, with no allowances. - */ -contract BasicToken is ERC20Basic { - using SafeMath for uint256; - - mapping(address => uint256) balances; - - uint256 totalSupply_; - - /** - * @dev total number of tokens in existence - */ - function totalSupply() public view returns (uint256) { - return totalSupply_; - } - - /** - * @dev transfer token for a specified address - * @param _to The address to transfer to. - * @param _value The amount to be transferred. - */ - function transfer(address _to, uint256 _value) public returns (bool) { - require(_to != address(0)); - require(_value <= balances[msg.sender]); - - // SafeMath.sub will throw if there is not enough balance. - balances[msg.sender] = balances[msg.sender].sub(_value); - balances[_to] = balances[_to].add(_value); - Transfer(msg.sender, _to, _value); - return true; - } - - /** - * @dev Gets the balance of the specified address. - * @param _owner The address to query the the balance of. - * @return An uint256 representing the amount owned by the passed address. - */ - function balanceOf(address _owner) public view returns (uint256 balance) { - return balances[_owner]; - } - -} - - - - - - -/** - * @title ERC20 interface - * @dev see https://github.com/ethereum/EIPs/issues/20 - */ -contract ERC20 is ERC20Basic { - function allowance(address owner, address spender) public view returns (uint256); - function transferFrom(address from, address to, uint256 value) public returns (bool); - function approve(address spender, uint256 value) public returns (bool); - event Approval(address indexed owner, address indexed spender, uint256 value); -} - - - -/** - * @title Standard ERC20 token - * - * @dev Implementation of the basic standard token. - * @dev https://github.com/ethereum/EIPs/issues/20 - * @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol - */ -contract StandardToken is ERC20, BasicToken { - - mapping (address => mapping (address => uint256)) internal allowed; - - - /** - * @dev Transfer tokens from one address to another - * @param _from address The address which you want to send tokens from - * @param _to address The address which you want to transfer to - * @param _value uint256 the amount of tokens to be transferred - */ - function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { - require(_to != address(0)); - require(_value <= balances[_from]); - require(_value <= allowed[_from][msg.sender]); - - balances[_from] = balances[_from].sub(_value); - balances[_to] = balances[_to].add(_value); - allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); - Transfer(_from, _to, _value); - return true; - } - - /** - * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender. - * - * Beware that changing an allowance with this method brings the risk that someone may use both the old - * and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this - * race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards: - * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 - * @param _spender The address which will spend the funds. - * @param _value The amount of tokens to be spent. - */ - function approve(address _spender, uint256 _value) public returns (bool) { - allowed[msg.sender][_spender] = _value; - Approval(msg.sender, _spender, _value); - return true; - } - - /** - * @dev Function to check the amount of tokens that an owner allowed to a spender. - * @param _owner address The address which owns the funds. - * @param _spender address The address which will spend the funds. - * @return A uint256 specifying the amount of tokens still available for the spender. - */ - function allowance(address _owner, address _spender) public view returns (uint256) { - return allowed[_owner][_spender]; - } - - /** - * @dev Increase the amount of tokens that an owner allowed to a spender. - * - * approve should be called when allowed[_spender] == 0. To increment - * allowed value is better to use this function to avoid 2 calls (and wait until - * the first transaction is mined) - * From MonolithDAO Token.sol - * @param _spender The address which will spend the funds. - * @param _addedValue The amount of tokens to increase the allowance by. - */ - function increaseApproval(address _spender, uint _addedValue) public returns (bool) { - allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue); - Approval(msg.sender, _spender, allowed[msg.sender][_spender]); - return true; - } - - /** - * @dev Decrease the amount of tokens that an owner allowed to a spender. - * - * approve should be called when allowed[_spender] == 0. To decrement - * allowed value is better to use this function to avoid 2 calls (and wait until - * the first transaction is mined) - * From MonolithDAO Token.sol - * @param _spender The address which will spend the funds. - * @param _subtractedValue The amount of tokens to decrease the allowance by. - */ - function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) { - uint oldValue = allowed[msg.sender][_spender]; - if (_subtractedValue > oldValue) { - allowed[msg.sender][_spender] = 0; - } else { - allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue); - } - Approval(msg.sender, _spender, allowed[msg.sender][_spender]); - return true; - } - -} - - - - - - - - - - - -/** - * @title Whitelist - * @dev The Whitelist contract has a whitelist of addresses, and provides basic authorization control functions. - * @dev This simplifies the implementation of "user permissions". - */ -contract Whitelist is Ownable { - mapping(address => bool) public whitelist; - - event WhitelistedAddressAdded(address addr); - event WhitelistedAddressRemoved(address addr); - - /** - * @dev Throws if called by any account that's not whitelisted. - */ - modifier onlyWhitelisted() { - require(whitelist[msg.sender]); - _; - } - - /** - * @dev add an address to the whitelist - * @param addr address - * @return true if the address was added to the whitelist, false if the address was already in the whitelist - */ - function addAddressToWhitelist(address addr) onlyOwner public returns(bool success) { - if (!whitelist[addr]) { - whitelist[addr] = true; - WhitelistedAddressAdded(addr); - success = true; - } - } - - /** - * @dev add addresses to the whitelist - * @param addrs addresses - * @return true if at least one address was added to the whitelist, - * false if all addresses were already in the whitelist - */ - function addAddressesToWhitelist(address[] addrs) onlyOwner public returns(bool success) { - for (uint256 i = 0; i < addrs.length; i++) { - if (addAddressToWhitelist(addrs[i])) { - success = true; - } - } - } - - /** - * @dev remove an address from the whitelist - * @param addr address - * @return true if the address was removed from the whitelist, - * false if the address wasn't in the whitelist in the first place - */ - function removeAddressFromWhitelist(address addr) onlyOwner public returns(bool success) { - if (whitelist[addr]) { - whitelist[addr] = false; - WhitelistedAddressRemoved(addr); - success = true; - } - } - - /** - * @dev remove addresses from the whitelist - * @param addrs addresses - * @return true if at least one address was removed from the whitelist, - * false if all addresses weren't in the whitelist in the first place - */ - function removeAddressesFromWhitelist(address[] addrs) onlyOwner public returns(bool success) { - for (uint256 i = 0; i < addrs.length; i++) { - if (removeAddressFromWhitelist(addrs[i])) { - success = true; - } - } - } - -} - - -contract OceanTokenTransferManager is Ownable, Whitelist { - - /** - * @dev check if transferFrom is possible - * @param _from address The address which you want to send tokens from - * @param _to address The address which you want to transfer to - */ - function canTransferFrom(address _from, address _to) public constant returns (bool success) { - if (whitelist[_from] == true || whitelist[_to] == true) { - return true; - } else { - return false; - } - } -} - - -contract OceanToken is StandardToken, Ownable { - event Airdrop(address indexed _to, uint256 _amount); - - string public constant name = 'The Ocean Token'; - string public constant symbol = 'OCEAN'; - uint8 public constant decimals = 18; - - OceanTokenTransferManager public transferManagerContract; - - /** - * @dev Airdrop the specified amount to the address - * @param _to The address that will receive the airdropped tokens. - * @param _requestedAmount The amount of tokens to airdrop. - * @return A boolean that indicates if the operation was successful. - */ - function airdrop(address _to, uint256 _requestedAmount) onlyOwner public returns (bool) { - uint256 _amountToDrop = _requestedAmount; - - totalSupply_ = totalSupply_.add(_amountToDrop); - balances[_to] = balances[_to].add(_amountToDrop); - emit Airdrop(_to, _amountToDrop); - emit Transfer(address(0), _to, _amountToDrop); - - return true; - } - - /** - * @dev Transfer tokens from one address to another - * @param _from address The address which you want to send tokens from - * @param _to address The address which you want to transfer to - * @param _value uint256 the amount of tokens to be transferred - */ - function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { - require(_to != address(0)); - require(_value <= balances[_from]); - require(_value <= allowed[_from][msg.sender]); - - // trading possible when at least one from list [_from, _to] is whitelisted - require(transferManagerContract.canTransferFrom(_from, _to)); - - balances[_from] = balances[_from].sub(_value); - balances[_to] = balances[_to].add(_value); - allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); - emit Transfer(_from, _to, _value); - return true; - } - - function setTransferManagerContract(OceanTokenTransferManager _transferManagerContract) onlyOwner public { - transferManagerContract = _transferManagerContract; - } -} \ No newline at end of file diff --git a/slither/tools/slither_format/tests/runSlitherFormat.py b/slither/tools/slither_format/tests/runSlitherFormat.py deleted file mode 100644 index 4f0efd84c..000000000 --- a/slither/tools/slither_format/tests/runSlitherFormat.py +++ /dev/null @@ -1,24 +0,0 @@ -from os import listdir -from os.path import isfile, join -import subprocess - -contracts_path = "../../smart-contracts-detectors-testing/most_used/contracts/" -slither_format_output_path = "./slither_format/tests/slither_format_output_most_used_contracts/" - -def analyze_contract_with_slither_format(): - for contract_file in contract_files: - run_slither_format(contract_file) - -def run_slither_format(contract_name): - print("Running Slither Format on contract: " + contract_name) - command = "python3 -m slither_format " + contracts_path+contract_name - contract_slither_output_fd = open(slither_format_output_path+contract_name[:-21]+".txt","w+") - contract_slither_output_fd.write("Command run: " + command + "\n\n") - contract_slither_output_fd.flush() - result = subprocess.run(command, shell=True, stdout=contract_slither_output_fd, stderr=contract_slither_output_fd) - contract_slither_output_fd.close() - -if __name__ == "__main__": - contract_files = [f for f in listdir(contracts_path) if f.endswith(".sol")] - print("Number of contract files: " + str(len(contract_files))) - analyze_contract_with_slither_format() diff --git a/slither/tools/slither_format/tests/run_all_tests.py b/slither/tools/slither_format/tests/run_all_tests.py deleted file mode 100644 index d158a33bc..000000000 --- a/slither/tools/slither_format/tests/run_all_tests.py +++ /dev/null @@ -1,22 +0,0 @@ -import subprocess - -p9 = subprocess.Popen(['python3', './slither_format/tests/test_unicode.py']) -p9.wait() -p8 = subprocess.Popen(['python3', './slither_format/tests/test_detector_combinations.py']) -p8.wait() -p7 = subprocess.Popen(['python3', './slither_format/tests/test_solc_version.py']) -p7.wait() -p6 = subprocess.Popen(['python3', './slither_format/tests/test_pragma.py']) -p6.wait() -p5 = subprocess.Popen(['python3', './slither_format/tests/test_naming_convention.py']) -p5.wait() -p4 = subprocess.Popen(['python3', './slither_format/tests/test_unused_state_vars.py']) -p4.wait() -p3 = subprocess.Popen(['python3', './slither_format/tests/test_external_function.py']) -p3.wait() -p2 = subprocess.Popen(['python3', './slither_format/tests/test_constant_function.py']) -p2.wait() -p1 = subprocess.Popen(['python3', './slither_format/tests/test_constable_states.py']) -p1.wait() - - diff --git a/slither/tools/slither_format/tests/test_constable_states.py b/slither/tools/slither_format/tests/test_constable_states.py deleted file mode 100644 index ade821b76..000000000 --- a/slither/tools/slither_format/tests/test_constable_states.py +++ /dev/null @@ -1,57 +0,0 @@ -import unittest -import subprocess, os, sys - -class TestConstableState(unittest.TestCase): - testDataFile = "const_state_variables.sol" - testDataDir = "./slither_format/tests/test_data/" - testFilePath = testDataDir+testDataFile - - def setUp(self): - outFD = open(self.testFilePath+".out","w") - errFD = open(self.testFilePath+".err","w") - p = subprocess.Popen(['python3', '-m', 'slither_format','--verbose-test','--detect','constable-states',self.testFilePath], stdout=outFD,stderr=errFD) - p.wait() - outFD.close() - errFD.close() - - def tearDown(self): - p = subprocess.Popen(['rm','-f',self.testFilePath+'.out',self.testFilePath+'.err',self.testFilePath+'.format']) - p.wait() - - def test_constable_states(self): - errFD = open(self.testFilePath+".err","r") - errFD_lines = errFD.readlines() - for i in range(len(errFD_lines)): - errFD_lines[i] = errFD_lines[i].strip() - self.assertTrue(os.path.isfile(self.testFilePath+".format"),"Patched .format file is not created?!") - self.assertEqual(errFD_lines[0].rstrip(),"INFO:Slither.Format:Number of Slither results: 6") - self.assertEqual(errFD_lines[1].rstrip(),"INFO:Slither.Format:Number of patches: 6") - self.assertEqual(errFD_lines.count("INFO:Slither.Format:Detector: constable-states"), 6) - self.assertEqual(errFD_lines.count("INFO:Slither.Format:Old string: address public myFriendsAddress = 0xc0ffee254729296a45a3885639AC7E10F9d54979"), 1) - self.assertEqual(errFD_lines.count("INFO:Slither.Format:New string: address public constant myFriendsAddress = 0xc0ffee254729296a45a3885639AC7E10F9d54979"), 1) - self.assertEqual(errFD_lines.count("INFO:Slither.Format:Location start: 132"), 1) - self.assertEqual(errFD_lines.count("INFO:Slither.Format:Location end: 208"), 1) - self.assertEqual(errFD_lines.count("INFO:Slither.Format:Old string: uint public test = 5"), 1) - self.assertEqual(errFD_lines.count("INFO:Slither.Format:New string: uint public constant test = 5"), 1) - self.assertEqual(errFD_lines.count("INFO:Slither.Format:Location start: 237"), 1) - self.assertEqual(errFD_lines.count("INFO:Slither.Format:Location end: 257"), 1) - self.assertEqual(errFD_lines.count("INFO:Slither.Format:Old string: string text2 = \"xyz\""), 1) - self.assertEqual(errFD_lines.count("INFO:Slither.Format:New string: string constant text2 = \"xyz\""), 1) - self.assertEqual(errFD_lines.count("INFO:Slither.Format:Location start: 333"), 1) - self.assertEqual(errFD_lines.count("INFO:Slither.Format:Location end: 353"), 1) - self.assertEqual(errFD_lines.count("INFO:Slither.Format:Old string: address public mySistersAddress = 0x999999cf1046e68e36E1aA2E0E07105eDDD1f08E"), 1) - self.assertEqual(errFD_lines.count("INFO:Slither.Format:New string: address public constant mySistersAddress = 0x999999cf1046e68e36E1aA2E0E07105eDDD1f08E"), 1) - self.assertEqual(errFD_lines.count("INFO:Slither.Format:Location start: 496"), 1) - self.assertEqual(errFD_lines.count("INFO:Slither.Format:Location end: 572"), 1) - self.assertEqual(errFD_lines.count("INFO:Slither.Format:Old string: bytes32 should_be_constant = sha256('abc')"), 1) - self.assertEqual(errFD_lines.count("INFO:Slither.Format:New string: bytes32 constant should_be_constant = sha256('abc')"), 1) - self.assertEqual(errFD_lines.count("INFO:Slither.Format:Location start: 793"), 1) - self.assertEqual(errFD_lines.count("INFO:Slither.Format:Location end: 835"), 1) - self.assertEqual(errFD_lines.count("INFO:Slither.Format:Old string: uint should_be_constant_2 = A + 1"), 1) - self.assertEqual(errFD_lines.count("INFO:Slither.Format:New string: uint constant should_be_constant_2 = A + 1"), 1) - self.assertEqual(errFD_lines.count("INFO:Slither.Format:Location start: 841"), 1) - self.assertEqual(errFD_lines.count("INFO:Slither.Format:Location end: 874"), 1) - errFD.close() - -if __name__ == '__main__': - unittest.main() diff --git a/slither/tools/slither_format/tests/test_constant_function.py b/slither/tools/slither_format/tests/test_constant_function.py deleted file mode 100644 index 9458545e6..000000000 --- a/slither/tools/slither_format/tests/test_constant_function.py +++ /dev/null @@ -1,65 +0,0 @@ -import unittest -import subprocess, os, sys - -class TestConstantFunctions(unittest.TestCase): - testDataFile1 = "constant.sol" - testDataFile2 = "constant-0.5.1.sol" - testDataDir = "./slither_format/tests/test_data/" - testFilePath1 = testDataDir+testDataFile1 - testFilePath2 = testDataDir+testDataFile2 - - def setUp(self): - outFD1 = open(self.testFilePath1+".out","w") - errFD1 = open(self.testFilePath1+".err","w") - p1 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose-test','--detect','constant-function',self.testFilePath1], stdout=outFD1,stderr=errFD1) - p1.wait() - outFD2 = open(self.testFilePath2+".out","w") - errFD2 = open(self.testFilePath2+".err","w") - p2 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose-test','--detect','constant-function',self.testFilePath2], stdout=outFD2,stderr=errFD2) - p2.wait() - outFD1.close() - errFD1.close() - outFD2.close() - errFD2.close() - - def tearDown(self): - p1 = subprocess.Popen(['rm','-f',self.testFilePath1+'.out',self.testFilePath1+'.err',self.testFilePath1+'.format']) - p1.wait() - p2 = subprocess.Popen(['rm','-f',self.testFilePath2+'.out',self.testFilePath2+'.err',self.testFilePath2+'.format']) - p2.wait() - - def test_constant_function(self): - errFD1 = open(self.testFilePath1+".err","r") - errFD1_lines = errFD1.readlines() - for i in range(len(errFD1_lines)): - errFD1_lines[i] = errFD1_lines[i].strip() - self.assertTrue(os.path.isfile(self.testFilePath1+".format"),"Patched .format file is not created?!") - self.assertEqual(errFD1_lines[0],"INFO:Slither.Format:Number of Slither results: 3") - self.assertEqual(errFD1_lines[1],"INFO:Slither.Format:Number of patches: 3") - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Detector: constant-function"), 3) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Old string: view"), 2) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Old string: constant"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:New string:"), 3) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 77"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 81"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 149"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 157"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 360"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 364"), 1) - errFD1.close() - - errFD2 = open(self.testFilePath2+".err","r") - errFD2_lines = errFD2.readlines() - for i in range(len(errFD2_lines)): - errFD2_lines[i] = errFD2_lines[i].strip() - self.assertTrue(os.path.isfile(self.testFilePath2+".format"),"Patched .format file is not created?!") - self.assertEqual(errFD2_lines[0],"INFO:Slither.Format:Number of Slither results: 1") - self.assertEqual(errFD2_lines[1],"INFO:Slither.Format:Number of patches: 1") - self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Old string: view"), 1) - self.assertEqual(errFD2_lines.count("INFO:Slither.Format:New string:"), 1) - self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Location start: 221"), 1) - self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Location end: 225"), 1) - errFD2.close() - -if __name__ == '__main__': - unittest.main() diff --git a/slither/tools/slither_format/tests/test_data/const_state_variables.sol b/slither/tools/slither_format/tests/test_data/const_state_variables.sol deleted file mode 100644 index aed05d97f..000000000 --- a/slither/tools/slither_format/tests/test_data/const_state_variables.sol +++ /dev/null @@ -1,52 +0,0 @@ -//pragma solidity ^0.4.24; - - -contract A { - - address constant public MY_ADDRESS = 0xE0f5206BBD039e7b0592d8918820024e2a7437b9; - address public myFriendsAddress = 0xc0ffee254729296a45a3885639AC7E10F9d54979; - - uint public used; - uint public test = 5; - - uint constant X = 32**22 + 8; - string constant TEXT1 = "abc"; - string text2 = "xyz"; - - function setUsed() public { - if (msg.sender == MY_ADDRESS) { - used = test; - } - } -} - - -contract B is A { - - address public mySistersAddress = 0x999999cf1046e68e36E1aA2E0E07105eDDD1f08E; - - function () external { - used = 0; - } - - function setUsed(uint a) public { - if (msg.sender == MY_ADDRESS) { - used = a; - } - } -} - -contract MyConc{ - - uint constant A = 1; - bytes32 should_be_constant = sha256('abc'); - uint should_be_constant_2 = A + 1; - address not_constant = msg.sender; - uint not_constant_2 = getNumber(); - uint not_constant_3 = 10 + block.number; - - function getNumber() public returns(uint){ - return block.number; - } - -} diff --git a/slither/tools/slither_format/tests/test_data/constant-0.5.1.sol b/slither/tools/slither_format/tests/test_data/constant-0.5.1.sol deleted file mode 100644 index 3293ab45d..000000000 --- a/slither/tools/slither_format/tests/test_data/constant-0.5.1.sol +++ /dev/null @@ -1,18 +0,0 @@ -contract Constant { - - uint a; - - - function test_view_shadow() public view{ - uint a; - a = 0; - } - - function test_view() public view{ - a; - } - - function test_assembly_bug() public view{ - assembly{} - } -} diff --git a/slither/tools/slither_format/tests/test_data/constant.sol b/slither/tools/slither_format/tests/test_data/constant.sol deleted file mode 100644 index 934634803..000000000 --- a/slither/tools/slither_format/tests/test_data/constant.sol +++ /dev/null @@ -1,25 +0,0 @@ -contract Constant { - - uint a; - - function test_view_bug() public view{ - a = 0; - } - - function test_constant_bug() public constant{ - a = 0; - } - - function test_view_shadow() public view{ - uint a; - a = 0; - } - - function test_view() public view{ - a; - } - - function test_assembly_bug() public view{ - assembly{} - } -} diff --git a/slither/tools/slither_format/tests/test_data/detector_combinations.sol b/slither/tools/slither_format/tests/test_data/detector_combinations.sol deleted file mode 100644 index 99011adcf..000000000 --- a/slither/tools/slither_format/tests/test_data/detector_combinations.sol +++ /dev/null @@ -1,48 +0,0 @@ -pragma solidity ^0.4.24; - -contract A { - - /* constant state variable naming - bad */ - /* unused state variable - bad */ - /* Overlapping detectors - so neither will be applied for now */ - uint max_tx = 100; - - /* state variable declaration naming convention - bad */ - uint SV_count = 0; - - modifier mod (uint c) { - require (c > 100); - _; - } - - /* parameter declaration naming convention - bad */ - function foo(uint Count) { - /* parameter use naming convention- bad */ - /* state variable use naming convention - bad */ - SV_count = Count; - } - - /* implicitly public, can be made external - bad */ - /* parameter declarations naming convention - bad */ - function foobar(uint Count, uint Number) returns (uint) { - /* parameter use naming convention - bad */ - foo (Number); - /* parameter use naming convention - bad */ - return (Count+Number); - } - - /* explicitly public, can be made external - bad */ - /* view but modifies state - bad */ - /* parameter declarations naming convention - bad */ - /* parameter use passed to modifier naming convention - bad */ - function bar(uint Count) public view mod (Count) returns(uint) { - /* Use of state variable naming convention - bad */ - /* Use of parameter naming convention - bad */ - SV_count += Count; - /* Use of state variable naming convention - bad */ - return (SV_count); - } - -} - - diff --git a/slither/tools/slither_format/tests/test_data/external_function.sol b/slither/tools/slither_format/tests/test_data/external_function.sol deleted file mode 100644 index af8037cbe..000000000 --- a/slither/tools/slither_format/tests/test_data/external_function.sol +++ /dev/null @@ -1,121 +0,0 @@ -//pragma solidity ^0.4.24; - -import "./external_function_import.sol"; - -contract ContractWithFunctionCalledSuper is ContractWithFunctionCalled { - function callWithSuper() public { - uint256 i = 0; - } -} - -contract ContractWithFunctionNotCalled { - - modifier mod (uint c) { - require (c > 0); - _; - } - - // With parameter and return - function funcNotCalled5(uint _i) - public returns (uint) { - return(_i + 10); - } - - // With no visibility specifier which is ok until solc 0.5.0 - function funcNotCalled4() { - } - - function funcNotCalled3() public - returns (uint a) - { - a = 100; - } - - function funcNotCalled2() public { - } - - function funcNotCalled() public { - } - - function my_func() internal returns(bool) { - return true; - } - - /* Cannot be converted to external because parameter i is written to in function and so cannot be in calldata */ - function test4(uint i) public returns(uint){ - i += 1; - return(i); - } - - /* public with modifier */ - function test5(uint number) public mod (number) returns(uint){ - return(number); - } - - /* implicit with modifier */ - function test6(uint number) mod (number) returns(uint){ - return(number); - } - -} - -contract ContractWithFunctionNotCalled2 is ContractWithFunctionCalledSuper { - function funcNotCalled() public { - uint256 i = 0; - address three = address(new ContractWithFunctionNotCalled()); - three.call(abi.encode(bytes4(keccak256("helloTwo()")))); - super.callWithSuper(); - ContractWithFunctionCalled c = new ContractWithFunctionCalled(); - c.funcCalled(); - } -} - -contract InternalCall { - - function() returns(uint) ptr; - - function set_test1() external{ - ptr = test1; - } - - function set_test2() external{ - ptr = test2; - } - - function test1() public returns(uint){ - return 1; - } - - function test2() public returns(uint){ - return 2; - } - - function test3() public returns(uint){ - return 3; - } - - function exec() external returns(uint){ - return ptr(); - } - -} - -contract publicKeywordTest { - - modifier publicMod() { - _; - } - - function test1(uint k) public{ - } - - function test2() publicMod { - } - - function test3() publicMod public { - } - - function test4(uint k)public{ - } - -} diff --git a/slither/tools/slither_format/tests/test_data/external_function_2.sol b/slither/tools/slither_format/tests/test_data/external_function_2.sol deleted file mode 100644 index 97eed10a0..000000000 --- a/slither/tools/slither_format/tests/test_data/external_function_2.sol +++ /dev/null @@ -1,55 +0,0 @@ -// This tests against false-positives. This test should output no recommendations from the external-function detector. - - -contract ContractWithBaseFunctionCalled { - function getsCalledByBase() public; - function callsOverrideMe() external { - getsCalledByBase(); - } -} - - -contract DerivingContractWithBaseCalled is ContractWithBaseFunctionCalled { - function getsCalledByBase() public { - // This should not be recommended to be marked external because it is called by the base class. - } -} - - -// All the contracts below should not recommend changing to external since inherited contracts have dynamic calls. -contract ContractWithDynamicCall { - function() returns(uint) ptr; - - function test1() public returns(uint){ - return 1; - } - - function test2() public returns(uint){ - return 2; - } - - function setTest1() external{ - ptr = test1; - } - - function setTest2() external{ - ptr = test2; - } - - function exec() external returns(uint){ - return ptr(); - } -} - -contract DerivesFromDynamicCall is ContractWithDynamicCall{ - function getsCalledDynamically() public returns (uint){ - // This should not be recommended because it is called dynamically. - return 3; - } - function setTest3() public { - // This should not be recommended because we inherit from a contract that calls dynamically, and we cannot be - // sure it did not somehow call this function. - - ptr = getsCalledDynamically; - } -} diff --git a/slither/tools/slither_format/tests/test_data/external_function_import.sol b/slither/tools/slither_format/tests/test_data/external_function_import.sol deleted file mode 100644 index efddea28e..000000000 --- a/slither/tools/slither_format/tests/test_data/external_function_import.sol +++ /dev/null @@ -1,7 +0,0 @@ -// This file is imported by external_function.sol - -contract ContractWithFunctionCalled { - function funcCalled() external { - uint256 i = 0; - } -} diff --git a/slither/tools/slither_format/tests/test_data/naming_convention.sol b/slither/tools/slither_format/tests/test_data/naming_convention.sol deleted file mode 100644 index 3420da1f1..000000000 --- a/slither/tools/slither_format/tests/test_data/naming_convention.sol +++ /dev/null @@ -1,108 +0,0 @@ -pragma solidity ^0.4.24; - -contract naming { - - enum Numbers {ONE, TWO} - enum numbers {ONE, TWO} - - numbers nums = numbers.TWO; - - uint constant MY_CONSTANT = 1; - uint constant MY_other_CONSTANT = 2; - - uint Var_One = 1; uint varTwo = 2; - - struct test { - uint a; - } - - struct Test { - uint a; - } - - test t; - - event Event_(uint); - event event_(uint); - - uint Number2; - - function getOne(bytes32 b) view public returns(uint) { - return MY_other_CONSTANT; - } - - function getOne(uint i) view public returns(numbers) { - numbers num; - num = numbers.ONE; - return(num); - } - - function getOne() view public returns(uint) - { - uint naming; - naming = GetOne(naming); - event_(naming); - return 1; - } - - function GetOne(uint i) view public returns (uint) - { - return (1 + Number2); - } - - function setInt(uint number1, uint Number2) public - { - uint i = number1 + Number2; - } - - - modifier CantDo() { - _; - } - - modifier canDo() { - _; - } -} - -contract Test { - naming n; - - function foo() { - n.GetOne(10); - } -} - -contract T { - uint private _myPrivateVar; - uint _myPublicVar; - - modifier ModifierTest() { - _; - } - - modifier modifierTestContractTypes(naming m1) { - naming m2; - _; - } - - function functionTestModifier(uint i) public ModifierTest returns(uint) { - return _myPrivateVar; - } - - function functionTestContractTypes(naming n1) public returns(naming) { - naming n2; - return(n2); - } - - function test(uint _unused, uint _used) public returns(uint){ - return _used; - } - - - uint k = 1; - - uint constant M = 1; - - uint l = 1; -} diff --git a/slither/tools/slither_format/tests/test_data/naming_convention_contract.sol b/slither/tools/slither_format/tests/test_data/naming_convention_contract.sol deleted file mode 100644 index 52349410b..000000000 --- a/slither/tools/slither_format/tests/test_data/naming_convention_contract.sol +++ /dev/null @@ -1,51 +0,0 @@ -pragma solidity ^0.4.24; - -/* contract definitione */ -contract one { - /* contract declaration as state variable */ - three k; - - function foo(uint i) { - /* contract declaration as local variable */ - three l; - l.foo(10); - k.foo(10); - } -} - -/* contract definitione */ -contract Two { - /* contract declaration as state variable */ - one m; - - function foo() { - /* contract declaration as local variable */ - one n; - n.foo(10); - m.foo(100); - } - -} - -/* contract definitione */ -contract three { - /* contract declaration as state variable */ - Two o; - - /* contract as function return value */ - function foo(uint i) returns (one) { - /* contract declaration as local variable */ - Two p; - p.foo(); - o.foo(); - /* new contract object */ - one r = new one(); - return(r); - } - - /* contract as function parameter */ - function foobar(one q) { - q.foo(10); - } -} - diff --git a/slither/tools/slither_format/tests/test_data/naming_convention_enum.sol b/slither/tools/slither_format/tests/test_data/naming_convention_enum.sol deleted file mode 100644 index 2f4f37904..000000000 --- a/slither/tools/slither_format/tests/test_data/naming_convention_enum.sol +++ /dev/null @@ -1,53 +0,0 @@ -pragma solidity ^0.4.24; - -contract A { - - /* enum definition - bad */ - enum e {ONE, TWO} - - /* enum declaration - bad */ - e e1; - - function foo() { - /* enum use - bad */ - e1 = e.ONE; - } -} - -contract B { - - /* enum definition - good */ - enum E {ONE, TWO} - - /* enum definition - good */ - E e1; - - function foo() { - /* enum use - good */ - e1 = E.ONE; - } - -} - -contract C { - - /* enum definition - bad */ - enum e {ONE, TWO} - - /* enum declaration - bad */ - e e1; - - /* enum as parameter and return value - bad */ - function foo(e eA) returns (e) { - e e2 = eA; - return (e2); - } -} - -contract D is C { - /* enum as parameter and return value - bad */ - function foo(e eA) returns (e) { - e e2 = eA; - return (e2); - } -} diff --git a/slither/tools/slither_format/tests/test_data/naming_convention_event.sol b/slither/tools/slither_format/tests/test_data/naming_convention_event.sol deleted file mode 100644 index f53967043..000000000 --- a/slither/tools/slither_format/tests/test_data/naming_convention_event.sol +++ /dev/null @@ -1,40 +0,0 @@ -pragma solidity ^0.4.24; - -contract One { - /* event declaration - bad */ - event e(uint); - - function foo(uint i) { - /* event call - bad */ - e(i); - } -} - -contract Two { - /* event declaration - good */ - event E(uint); - - function foo(uint i) { - /* event call - good */ - E(i); - } - -} - -contract Three { - /* event declaration - bad */ - event e(uint); - - function foo(uint i) { - /* event call with emit - bad */ - emit e(i); - } - -} - -contract Four is Three { - function foo(uint i) { - /* event call with emit - bad */ - emit e(i); - } -} diff --git a/slither/tools/slither_format/tests/test_data/naming_convention_function.sol b/slither/tools/slither_format/tests/test_data/naming_convention_function.sol deleted file mode 100644 index 042905112..000000000 --- a/slither/tools/slither_format/tests/test_data/naming_convention_function.sol +++ /dev/null @@ -1,33 +0,0 @@ -pragma solidity ^0.4.24; - -contract A { - - /* function definition - bad */ - function Foo() { - /* function call - bad */ - uint i = Foobar(10); - } - - /* function definition - bad */ - function Foobar(uint i) returns (uint) { - return (1+10); - } - -} - -contract B { - /* function definition - good */ - function foo() { - /* function call - good */ - uint i = foobar(10); - } - - /* function definition - good */ - function foobar(uint i) returns (uint) { - A a; - /* function call - bad */ - return (a.Foobar(10) + i); - } -} - - diff --git a/slither/tools/slither_format/tests/test_data/naming_convention_modifier.sol b/slither/tools/slither_format/tests/test_data/naming_convention_modifier.sol deleted file mode 100644 index 3ae9efa17..000000000 --- a/slither/tools/slither_format/tests/test_data/naming_convention_modifier.sol +++ /dev/null @@ -1,53 +0,0 @@ -pragma solidity ^0.4.24; - -contract A { - - /* modifier definition - good */ - modifier one() { - _; - } - - /* modifier use - good */ - function foo() one { - } -} - -contract B { - /* modifier definition - bad */ - modifier One() { - _; - } - - /* modifier use - bad */ - function foo () One { - } - -} - -contract C { - - /* modifier definition - good */ - modifier one() { - _; - } - - /* modifier definition - bad */ - modifier Two() { - _; - } - - /* modifier uses - good and bad */ - function foo() one Two returns (uint) { - /* Local variable with same name as bad modifier name from contract B */ - uint One; - return(One); - } - -} - -contract D is C { - /* modifier uses - good and bad */ - function foo() one Two returns (uint) { - } -} - diff --git a/slither/tools/slither_format/tests/test_data/naming_convention_parameter.sol b/slither/tools/slither_format/tests/test_data/naming_convention_parameter.sol deleted file mode 100644 index de0719177..000000000 --- a/slither/tools/slither_format/tests/test_data/naming_convention_parameter.sol +++ /dev/null @@ -1,47 +0,0 @@ -pragma solidity ^0.4.24; - -contract A { - - /* parameter declaration - bad */ - function foo(uint Count) { - /* parameter use - bad */ - uint i = Count; - } - - /* parameter declarations - bad */ - function foobar(uint Count, uint Number) returns (uint) { - /* parameter declarations - bad */ - return (Count+Number); - } - - modifier mod (uint c) { - require (c > 100); - _; - } - - /* parameter declarations - bad */ - /* function parameter passed to modifier */ - function bar(uint Count) mod (Count) returns(uint) { - /* parameter declarations - bad */ - return (Count); - } - -} - - -contract B { - - mapping(address => uint256) balances; - - /* parameter declarations - bad */ - function bar(address _to, address _from) returns (uint){ - uint i; - /* parameter use - bad */ - i = balances[_to]; - /* parameter use - bad */ - balances[_from] = 100; - return(i); - } -} - - diff --git a/slither/tools/slither_format/tests/test_data/naming_convention_state_variable.sol b/slither/tools/slither_format/tests/test_data/naming_convention_state_variable.sol deleted file mode 100644 index 2e7239f71..000000000 --- a/slither/tools/slither_format/tests/test_data/naming_convention_state_variable.sol +++ /dev/null @@ -1,37 +0,0 @@ -pragma solidity ^0.4.24; - -contract A { - /* State variable declaration constant - good */ - uint constant NUMBER = 100; - /* State variable declaration private - good */ - uint private count = 100; - /* State variable declaration non-constant non-private - good */ - uint maxnum = 999; - - function foo() { - /* State variable uses - good */ - uint i = NUMBER + count + maxnum; - } -} - -contract B { - /* State variable declaration constant - bad */ - uint constant number = 100; - /* State variable declaration private - bad */ - uint private Count = 100; - /* State variable declaration non-constant non-private - good */ - uint Maxnum = 999; - function foo() { - /* State variable uses - bad */ - uint i = number + Count + Maxnum; - Count += i; - } -} - -contract C is B { - function foo() { - /* State variable uses - bad */ - uint i = number + Maxnum; - } -} - diff --git a/slither/tools/slither_format/tests/test_data/naming_convention_structure.sol b/slither/tools/slither_format/tests/test_data/naming_convention_structure.sol deleted file mode 100644 index 2d65af314..000000000 --- a/slither/tools/slither_format/tests/test_data/naming_convention_structure.sol +++ /dev/null @@ -1,58 +0,0 @@ -pragma solidity ^0.4.24; -pragma experimental ABIEncoderV2; - -contract A { - - /* struct definition - bad */ - struct s { - uint i; - } - - /* struct declaration - bad */ - s s1; - - function foo() { - s1.i = 10; - } -} - -contract B { - - /* struct definition - good */ - struct S { - uint i; - } - - /* struct definition - good */ - S s1; - - function foo() { - s1.i = 10; - } - -} - -contract C { - - /* struct definition - bad */ - struct s { - uint i; - } - - /* struct declaration - bad */ - s s1; - - /* struct as parameter and return value - bad */ - function foo(s sA) returns (s) { - s1.i = sA.i; - return (s1); - } -} - -contract D is C { - /* struct as parameter and return value - bad */ - function foo(s sA) returns (s) { - s1.i = sA.i; - return (s1); - } -} diff --git a/slither/tools/slither_format/tests/test_data/pragma.0.4.23.sol b/slither/tools/slither_format/tests/test_data/pragma.0.4.23.sol deleted file mode 100644 index 6e6a5000f..000000000 --- a/slither/tools/slither_format/tests/test_data/pragma.0.4.23.sol +++ /dev/null @@ -1 +0,0 @@ -pragma solidity ^0.4.23; diff --git a/slither/tools/slither_format/tests/test_data/pragma.0.4.24.sol b/slither/tools/slither_format/tests/test_data/pragma.0.4.24.sol deleted file mode 100644 index c10357dcc..000000000 --- a/slither/tools/slither_format/tests/test_data/pragma.0.4.24.sol +++ /dev/null @@ -1,5 +0,0 @@ -pragma solidity ^0.4.24; - -import "./pragma.0.4.23.sol"; - -contract Test{} diff --git a/slither/tools/slither_format/tests/test_data/pragma.0.5.2.sol b/slither/tools/slither_format/tests/test_data/pragma.0.5.2.sol deleted file mode 100644 index 00fff9302..000000000 --- a/slither/tools/slither_format/tests/test_data/pragma.0.5.2.sol +++ /dev/null @@ -1 +0,0 @@ -pragma solidity ^0.5.2; diff --git a/slither/tools/slither_format/tests/test_data/pragma.0.5.4.sol b/slither/tools/slither_format/tests/test_data/pragma.0.5.4.sol deleted file mode 100644 index 16297788e..000000000 --- a/slither/tools/slither_format/tests/test_data/pragma.0.5.4.sol +++ /dev/null @@ -1,5 +0,0 @@ -pragma solidity ^0.5.4; - -import "./pragma.0.5.2.sol"; - -contract Test{} diff --git a/slither/tools/slither_format/tests/test_data/solc_version_incorrect1.sol b/slither/tools/slither_format/tests/test_data/solc_version_incorrect1.sol deleted file mode 100644 index 1c517b087..000000000 --- a/slither/tools/slither_format/tests/test_data/solc_version_incorrect1.sol +++ /dev/null @@ -1,5 +0,0 @@ -// The version pragma below should get flagged by the detector -pragma solidity ^0.4.23; -contract Contract{ - -} diff --git a/slither/tools/slither_format/tests/test_data/solc_version_incorrect2.sol b/slither/tools/slither_format/tests/test_data/solc_version_incorrect2.sol deleted file mode 100644 index a29d1a18d..000000000 --- a/slither/tools/slither_format/tests/test_data/solc_version_incorrect2.sol +++ /dev/null @@ -1,5 +0,0 @@ -// The version pragma below should get flagged by the detector -pragma solidity >=0.4.0 <0.6.0; -contract Contract{ - -} diff --git a/slither/tools/slither_format/tests/test_data/solc_version_incorrect3.sol b/slither/tools/slither_format/tests/test_data/solc_version_incorrect3.sol deleted file mode 100644 index 912616455..000000000 --- a/slither/tools/slither_format/tests/test_data/solc_version_incorrect3.sol +++ /dev/null @@ -1,5 +0,0 @@ -// The version pragma below should get flagged by the detector -pragma solidity >=0.4.0 <0.4.25; -contract Contract{ - -} diff --git a/slither/tools/slither_format/tests/test_data/solc_version_incorrect4.sol b/slither/tools/slither_format/tests/test_data/solc_version_incorrect4.sol deleted file mode 100644 index b93d43e93..000000000 --- a/slither/tools/slither_format/tests/test_data/solc_version_incorrect4.sol +++ /dev/null @@ -1,5 +0,0 @@ -// The version pragma below should get flagged by the detector -pragma solidity ^0.5.1; -contract Contract{ - -} diff --git a/slither/tools/slither_format/tests/test_data/unicode.sol b/slither/tools/slither_format/tests/test_data/unicode.sol deleted file mode 100644 index 19c83c44a..000000000 --- a/slither/tools/slither_format/tests/test_data/unicode.sol +++ /dev/null @@ -1,4 +0,0 @@ -contract C { - //领 - uint sv; -} diff --git a/slither/tools/slither_format/tests/test_data/unused_state.sol b/slither/tools/slither_format/tests/test_data/unused_state.sol deleted file mode 100644 index 50319c158..000000000 --- a/slither/tools/slither_format/tests/test_data/unused_state.sol +++ /dev/null @@ -1,13 +0,0 @@ -//pragma solidity ^0.4.24; - -contract A{ - address unused ; - address used; -} - -contract B is A{ - - function () external{ - used = address(0); - } -} diff --git a/slither/tools/slither_format/tests/test_detector_combinations.py b/slither/tools/slither_format/tests/test_detector_combinations.py deleted file mode 100644 index 6ea90ccf0..000000000 --- a/slither/tools/slither_format/tests/test_detector_combinations.py +++ /dev/null @@ -1,42 +0,0 @@ -import unittest -import subprocess, os, sys - -class TestDetectorCombinations(unittest.TestCase): - testDataDir = "./slither_format/tests/test_data/" - testDataFile1 = "detector_combinations.sol" - testFilePath1 = testDataDir+testDataFile1 - - def setUp(self): - outFD1 = open(self.testFilePath1+".out","w") - errFD1 = open(self.testFilePath1+".err","w") - p1 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose-test',self.testFilePath1], stdout=outFD1,stderr=errFD1) - p1.wait() - outFD1.close() - errFD1.close() - - def tearDown(self): - p1 = subprocess.Popen(['rm','-f',self.testFilePath1+'.out',self.testFilePath1+'.err',self.testFilePath1+'.format']) - p1.wait() - - def test_detector_combinations(self): - errFD1 = open(self.testFilePath1+".err","r") - errFD1_lines = errFD1.readlines() - errFD1.close() - for i in range(len(errFD1_lines)): - errFD1_lines[i] = errFD1_lines[i].strip() - self.assertTrue(os.path.isfile(self.testFilePath1+".format"),"Patched .format file is not created?!") - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Number of Slither results: 12"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Number of patches: 18"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Overlapping patch won't be applied!"), 3) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:xDetector: unused-state"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:xDetector: constable-states"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:xDetector: naming-convention (state variable declaration)"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Detector: naming-convention (state variable declaration)"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Detector: naming-convention (state variable uses)"), 3) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Detector: naming-convention (parameter declaration)"), 4) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Detector: naming-convention (parameter uses)"), 6) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Detector: external-function"), 2) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Detector: constant-function"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Detector: solc-version"), 1) -if __name__ == '__main__': - unittest.main() diff --git a/slither/tools/slither_format/tests/test_external_function.py b/slither/tools/slither_format/tests/test_external_function.py deleted file mode 100644 index 039ebd7c3..000000000 --- a/slither/tools/slither_format/tests/test_external_function.py +++ /dev/null @@ -1,80 +0,0 @@ -import unittest -import subprocess, os, sys - -class TestExternalFunctions(unittest.TestCase): - testDataFile1 = "external_function.sol" - testDataFile2 = "external_function_2.sol" - testDataDir = "./slither_format/tests/test_data/" - testFilePath1 = testDataDir+testDataFile1 - testFilePath2 = testDataDir+testDataFile2 - - def setUp(self): - outFD1 = open(self.testFilePath1+".out","w") - errFD1 = open(self.testFilePath1+".err","w") - p1 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose-test','--detect','external-function',self.testFilePath1], stdout=outFD1,stderr=errFD1) - p1.wait() - outFD2 = open(self.testFilePath2+".out","w") - errFD2 = open(self.testFilePath2+".err","w") - p2 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose-test','--detect','external-function',self.testFilePath2], stdout=outFD2,stderr=errFD2) - p2.wait() - outFD1.close() - errFD1.close() - outFD2.close() - errFD2.close() - - def tearDown(self): - p1 = subprocess.Popen(['rm','-f',self.testFilePath1+'.out',self.testFilePath1+'.err',self.testFilePath1+'.format']) - p1.wait() - p2 = subprocess.Popen(['rm','-f',self.testFilePath2+'.out',self.testFilePath2+'.err',self.testFilePath2+'.format']) - p2.wait() - - def test_external_function(self): - errFD1 = open(self.testFilePath1+".err","r") - errFD1_lines = errFD1.readlines() - for i in range(len(errFD1_lines)): - errFD1_lines[i] = errFD1_lines[i].strip() - self.assertTrue(os.path.isfile(self.testFilePath1+".format"),"Patched .format file is not created?!") - self.assertEqual(errFD1_lines[0],"INFO:Slither.Format:Number of Slither results: 13") - self.assertEqual(errFD1_lines[1],"INFO:Slither.Format:Number of patches: 12") - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Detector: external-function"), 12) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Old string: public"), 9) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:New string: external"), 9) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 384"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 390"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 562"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 568"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 642"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 648"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 685"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 691"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 1022"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 1028"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 1305"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 1311"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 2197"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 2203"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 2275"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 2281"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 2315"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 2321"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Old string:"), 3) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:New string: external"), 3) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 524"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 524"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 1142"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 1142"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 2228"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 2228"), 1) - errFD1.close() - - errFD2 = open(self.testFilePath2+".err","r") - errFD2_lines = errFD2.readlines() - for i in range(len(errFD2_lines)): - errFD2_lines[i] = errFD2_lines[i].strip() - self.assertFalse(os.path.isfile(self.testFilePath2+".format"),"Patched .format file _is_ created?!") - self.assertEqual(errFD2_lines[0],"INFO:Slither.Format:Number of Slither results: 0") - self.assertEqual(errFD2_lines[1],"INFO:Slither.Format:Number of patches: 0") - errFD2.close() - -if __name__ == '__main__': - unittest.main() diff --git a/slither/tools/slither_format/tests/test_naming_convention.py b/slither/tools/slither_format/tests/test_naming_convention.py deleted file mode 100644 index 19ee2320d..000000000 --- a/slither/tools/slither_format/tests/test_naming_convention.py +++ /dev/null @@ -1,409 +0,0 @@ -import unittest -import subprocess, os, sys - -class TestNamingConvention(unittest.TestCase): - testDataDir = "./slither_format/tests/test_data/" - testDataFile1 = "naming_convention_contract.sol" - testDataFile2 = "naming_convention_modifier.sol" - testDataFile3 = "naming_convention_structure.sol" - testDataFile4 = "naming_convention_enum.sol" - testDataFile5 = "naming_convention_event.sol" - testDataFile6 = "naming_convention_function.sol" - testDataFile7 = "naming_convention_parameter.sol" - testDataFile8 = "naming_convention_state_variable.sol" - testFilePath1 = testDataDir+testDataFile1 - testFilePath2 = testDataDir+testDataFile2 - testFilePath3 = testDataDir+testDataFile3 - testFilePath4 = testDataDir+testDataFile4 - testFilePath5 = testDataDir+testDataFile5 - testFilePath6 = testDataDir+testDataFile6 - testFilePath7 = testDataDir+testDataFile7 - testFilePath8 = testDataDir+testDataFile8 - - def setUp(self): - outFD1 = open(self.testFilePath1+".out","w") - errFD1 = open(self.testFilePath1+".err","w") - p1 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose-test','--detect','naming-convention',self.testFilePath1], stdout=outFD1,stderr=errFD1) - p1.wait() - outFD1.close() - errFD1.close() - - outFD2 = open(self.testFilePath2+".out","w") - errFD2 = open(self.testFilePath2+".err","w") - p2 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose-test','--detect','naming-convention',self.testFilePath2], stdout=outFD2,stderr=errFD2) - p2.wait() - outFD2.close() - errFD2.close() - - outFD3 = open(self.testFilePath3+".out","w") - errFD3 = open(self.testFilePath3+".err","w") - p3 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose-test','--detect','naming-convention',self.testFilePath3], stdout=outFD3,stderr=errFD3) - p3.wait() - outFD3.close() - errFD3.close() - - outFD4 = open(self.testFilePath4+".out","w") - errFD4 = open(self.testFilePath4+".err","w") - p4 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose-test','--detect','naming-convention',self.testFilePath4], stdout=outFD4,stderr=errFD4) - p4.wait() - outFD4.close() - errFD4.close() - - outFD5 = open(self.testFilePath5+".out","w") - errFD5 = open(self.testFilePath5+".err","w") - p5 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose-test','--detect','naming-convention',self.testFilePath5], stdout=outFD5,stderr=errFD5) - p5.wait() - outFD5.close() - errFD5.close() - - outFD6 = open(self.testFilePath6+".out","w") - errFD6 = open(self.testFilePath6+".err","w") - p6 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose-test','--detect','naming-convention',self.testFilePath6], stdout=outFD6,stderr=errFD6) - p6.wait() - outFD6.close() - errFD6.close() - - outFD7 = open(self.testFilePath7+".out","w") - errFD7 = open(self.testFilePath7+".err","w") - p7 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose-test','--detect','naming-convention',self.testFilePath7], stdout=outFD7,stderr=errFD7) - p7.wait() - outFD7.close() - errFD7.close() - - outFD8 = open(self.testFilePath8+".out","w") - errFD8 = open(self.testFilePath8+".err","w") - p8 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose-test','--detect','naming-convention',self.testFilePath8], stdout=outFD8,stderr=errFD8) - p8.wait() - outFD8.close() - errFD8.close() - - def tearDown(self): - p1 = subprocess.Popen(['rm','-f',self.testFilePath1+'.out',self.testFilePath1+'.err',self.testFilePath1+'.format']) - p1.wait() - p2 = subprocess.Popen(['rm','-f',self.testFilePath2+'.out',self.testFilePath2+'.err',self.testFilePath2+'.format']) - p2.wait() - p3 = subprocess.Popen(['rm','-f',self.testFilePath3+'.out',self.testFilePath3+'.err',self.testFilePath3+'.format']) - p3.wait() - p4 = subprocess.Popen(['rm','-f',self.testFilePath4+'.out',self.testFilePath4+'.err',self.testFilePath4+'.format']) - p4.wait() - p5 = subprocess.Popen(['rm','-f',self.testFilePath5+'.out',self.testFilePath5+'.err',self.testFilePath5+'.format']) - p5.wait() - p6 = subprocess.Popen(['rm','-f',self.testFilePath6+'.out',self.testFilePath6+'.err',self.testFilePath6+'.format']) - p6.wait() - p7 = subprocess.Popen(['rm','-f',self.testFilePath7+'.out',self.testFilePath7+'.err',self.testFilePath7+'.format']) - p7.wait() - p8 = subprocess.Popen(['rm','-f',self.testFilePath8+'.out',self.testFilePath8+'.err',self.testFilePath8+'.format']) - p8.wait() - - def test_naming_convention_contract(self): - errFD1 = open(self.testFilePath1+".err","r") - errFD1_lines = errFD1.readlines() - errFD1.close() - for i in range(len(errFD1_lines)): - errFD1_lines[i] = errFD1_lines[i].strip() - self.assertTrue(os.path.isfile(self.testFilePath1+".format"),"Patched .format file is not created?!") - self.assertEqual(errFD1_lines[0],"INFO:Slither.Format:Number of Slither results: 2") - self.assertEqual(errFD1_lines[1],"INFO:Slither.Format:Number of patches: 10") - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Detector: naming-convention (contract definition)"), 2) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Detector: naming-convention (contract state variable)"), 2) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Detector: naming-convention (contract function variable)"), 5) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Detector: naming-convention (contract new object)"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Old string: contract one"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:New string: contract One"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 53"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 65"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Old string: three k"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:New string: Three k"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 117"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 124"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Old string: three l"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:New string: Three l"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 206"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 213"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Old string: one m"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:New string: One m"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 343"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 348"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Old string: one n"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:New string: One n"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 423"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 428"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Old string: contract three"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:New string: contract Three"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 498"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 512"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Old string: one"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:New string: One"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 646"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 649"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Old string: one r"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:New string: One r"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 773"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 779"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Old string: one q"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:New string: One q"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 871"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 876"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Old string: new one()"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:New string: new One()"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 781"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 788"), 1) - - def test_naming_convention_modifier(self): - errFD2 = open(self.testFilePath2+".err","r") - errFD2_lines = errFD2.readlines() - errFD2.close() - for i in range(len(errFD2_lines)): - errFD2_lines[i] = errFD2_lines[i].strip() - self.assertTrue(os.path.isfile(self.testFilePath2+".format"),"Patched .format file is not created?!") - self.assertEqual(errFD2_lines[0],"INFO:Slither.Format:Number of Slither results: 2") - self.assertEqual(errFD2_lines[1],"INFO:Slither.Format:Number of patches: 5") - self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Detector: naming-convention (modifier definition)"), 2) - self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Detector: naming-convention (modifier uses)"), 3) - self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Old string: modifier One"), 1) - self.assertEqual(errFD2_lines.count("INFO:Slither.Format:New string: modifier one"), 1) - self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Location start: 215"), 1) - self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Location end: 227"), 1) - self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Old string: () One"), 1) - self.assertEqual(errFD2_lines.count("INFO:Slither.Format:New string: () one"), 1) - self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Location start: 288"), 1) - self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Location end: 295"), 1) - self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Old string: modifier Two"), 1) - self.assertEqual(errFD2_lines.count("INFO:Slither.Format:New string: modifier two"), 1) - self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Location start: 423"), 1) - self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Location end: 435"), 1) - self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Old string: () one Two returns"), 2) - self.assertEqual(errFD2_lines.count("INFO:Slither.Format:New string: () one two returns"), 2) - self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Location start: 503"), 1) - self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Location end: 522"), 1) - self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Location start: 718"), 1) - self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Location end: 737"), 1) - - def test_naming_convention_structure(self): - errFD3 = open(self.testFilePath3+".err","r") - errFD3_lines = errFD3.readlines() - errFD3.close() - for i in range(len(errFD3_lines)): - errFD3_lines[i] = errFD3_lines[i].strip() - self.assertTrue(os.path.isfile(self.testFilePath3+".format"),"Patched .format file is not created?!") - self.assertEqual(errFD3_lines[0],"INFO:Slither.Format:Number of Slither results: 2") - self.assertEqual(errFD3_lines[1],"INFO:Slither.Format:Number of patches: 8") - self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Detector: naming-convention (struct definition)"), 2) - self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Detector: naming-convention (struct use)"), 6) - self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Old string: struct s { uint i; }"), 2) - self.assertEqual(errFD3_lines.count("INFO:Slither.Format:New string: struct S { uint i; }"), 2) - self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Location start: 108"), 1) - self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Location end: 134"), 1) - self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Location start: 434"), 1) - self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Location end: 460"), 1) - self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Old string: s s1"), 2) - self.assertEqual(errFD3_lines.count("INFO:Slither.Format:New string: S s1"), 2) - self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Location start: 171"), 1) - self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Location end: 175"), 1) - self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Location start: 497"), 1) - self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Location end: 501"), 1) - self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Old string: s sA"), 2) - self.assertEqual(errFD3_lines.count("INFO:Slither.Format:New string: S sA"), 2) - self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Location start: 570"), 1) - self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Location end: 574"), 1) - self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Location start: 715"), 1) - self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Location end: 719"), 1) - self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Old string: s"), 2) - self.assertEqual(errFD3_lines.count("INFO:Slither.Format:New string: S"), 2) - self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Location start: 585"), 1) - self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Location end: 586"), 1) - self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Location start: 730"), 1) - self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Location end: 731"), 1) - - def test_naming_convention_enum(self): - errFD4 = open(self.testFilePath4+".err","r") - errFD4_lines = errFD4.readlines() - errFD4.close() - for i in range(len(errFD4_lines)): - errFD4_lines[i] = errFD4_lines[i].strip() - self.assertTrue(os.path.isfile(self.testFilePath4+".format"),"Patched .format file is not created?!") - self.assertEqual(errFD4_lines[0],"INFO:Slither.Format:Number of Slither results: 2") - self.assertEqual(errFD4_lines[1],"INFO:Slither.Format:Number of patches: 11") - self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Detector: naming-convention (enum definition)"), 2) - self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Detector: naming-convention (enum use)"), 9) - self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Old string: enum e {ONE, TWO}"), 2) - self.assertEqual(errFD4_lines.count("INFO:Slither.Format:New string: enum E {ONE, TWO}"), 2) - self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location start: 73"), 1) - self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location end: 90"), 1) - self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location start: 426"), 1) - self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location end: 443"), 1) - self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Old string: e e1"), 2) - self.assertEqual(errFD4_lines.count("INFO:Slither.Format:New string: E e1"), 2) - self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location start: 125"), 1) - self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location end: 129"), 1) - self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location start: 478"), 1) - self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location end: 482"), 1) - self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Old string: e eA"), 2) - self.assertEqual(errFD4_lines.count("INFO:Slither.Format:New string: E eA"), 2) - self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location start: 549"), 1) - self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location end: 553"), 1) - self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location start: 690"), 1) - self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location end: 694"), 1) - self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Old string: e e2 = eA"), 2) - self.assertEqual(errFD4_lines.count("INFO:Slither.Format:New string: E e2 = eA"), 2) - self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location start: 573"), 1) - self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location end: 582"), 1) - self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location start: 714"), 1) - self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location end: 723"), 1) - self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Old string: e.ONE"), 1) - self.assertEqual(errFD4_lines.count("INFO:Slither.Format:New string: E.ONE"), 1) - self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location start: 186"), 1) - self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location end: 192"), 1) - self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Old string: e"), 2) - self.assertEqual(errFD4_lines.count("INFO:Slither.Format:New string: E"), 2) - self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location start: 564"), 1) - self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location end: 565"), 1) - self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location start: 705"), 1) - self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location end: 706"), 1) - - def test_naming_convention_event(self): - errFD5 = open(self.testFilePath5+".err","r") - errFD5_lines = errFD5.readlines() - errFD5.close() - for i in range(len(errFD5_lines)): - errFD5_lines[i] = errFD5_lines[i].strip() - self.assertTrue(os.path.isfile(self.testFilePath5+".format"),"Patched .format file is not created?!") - self.assertEqual(errFD5_lines[0],"INFO:Slither.Format:Number of Slither results: 2") - self.assertEqual(errFD5_lines[1],"INFO:Slither.Format:Number of patches: 5") - self.assertEqual(errFD5_lines.count("INFO:Slither.Format:Detector: naming-convention (event definition)"), 2) - self.assertEqual(errFD5_lines.count("INFO:Slither.Format:Detector: naming-convention (event calls)"), 3) - self.assertEqual(errFD5_lines.count("INFO:Slither.Format:Old string: event e(uint);"), 2) - self.assertEqual(errFD5_lines.count("INFO:Slither.Format:New string: event E(uint);"), 2) - self.assertEqual(errFD5_lines.count("INFO:Slither.Format:Location start: 75"), 1) - self.assertEqual(errFD5_lines.count("INFO:Slither.Format:Location end: 89"), 1) - self.assertEqual(errFD5_lines.count("INFO:Slither.Format:Location start: 148"), 1) - self.assertEqual(errFD5_lines.count("INFO:Slither.Format:Location end: 152"), 1) - self.assertEqual(errFD5_lines.count("INFO:Slither.Format:Old string: e(i)"), 3) - self.assertEqual(errFD5_lines.count("INFO:Slither.Format:New string: E(i)"), 3) - self.assertEqual(errFD5_lines.count("INFO:Slither.Format:Location start: 148"), 1) - self.assertEqual(errFD5_lines.count("INFO:Slither.Format:Location end: 152"), 1) - self.assertEqual(errFD5_lines.count("INFO:Slither.Format:Location start: 438"), 1) - self.assertEqual(errFD5_lines.count("INFO:Slither.Format:Location end: 442"), 1) - self.assertEqual(errFD5_lines.count("INFO:Slither.Format:Location start: 550"), 1) - self.assertEqual(errFD5_lines.count("INFO:Slither.Format:Location end: 554"), 1) - - def test_naming_convention_function(self): - errFD6 = open(self.testFilePath6+".err","r") - errFD6_lines = errFD6.readlines() - errFD6.close() - for i in range(len(errFD6_lines)): - errFD6_lines[i] = errFD6_lines[i].strip() - self.assertTrue(os.path.isfile(self.testFilePath6+".format"),"Patched .format file is not created?!") - self.assertEqual(errFD6_lines[0],"INFO:Slither.Format:Number of Slither results: 2") - self.assertEqual(errFD6_lines[1],"INFO:Slither.Format:Number of patches: 4") - self.assertEqual(errFD6_lines.count("INFO:Slither.Format:Detector: naming-convention (function definition)"), 2) - self.assertEqual(errFD6_lines.count("INFO:Slither.Format:Detector: naming-convention (function calls)"), 2) - self.assertEqual(errFD6_lines.count("INFO:Slither.Format:Old string: function Foo"), 1) - self.assertEqual(errFD6_lines.count("INFO:Slither.Format:New string: function foo"), 1) - self.assertEqual(errFD6_lines.count("INFO:Slither.Format:Location start: 76"), 1) - self.assertEqual(errFD6_lines.count("INFO:Slither.Format:Location end: 88"), 1) - self.assertEqual(errFD6_lines.count("INFO:Slither.Format:Old string: function Foobar"), 1) - self.assertEqual(errFD6_lines.count("INFO:Slither.Format:New string: function foobar"), 1) - self.assertEqual(errFD6_lines.count("INFO:Slither.Format:Location start: 189"), 1) - self.assertEqual(errFD6_lines.count("INFO:Slither.Format:Location end: 204"), 1) - self.assertEqual(errFD6_lines.count("INFO:Slither.Format:Old string: Foobar"), 1) - self.assertEqual(errFD6_lines.count("INFO:Slither.Format:New string: foobar"), 1) - self.assertEqual(errFD6_lines.count("INFO:Slither.Format:Location start: 136"), 1) - self.assertEqual(errFD6_lines.count("INFO:Slither.Format:Location end: 142"), 1) - self.assertEqual(errFD6_lines.count("INFO:Slither.Format:Old string: a.Foobar(10)"), 1) - self.assertEqual(errFD6_lines.count("INFO:Slither.Format:New string: a.foobar(10)"), 1) - self.assertEqual(errFD6_lines.count("INFO:Slither.Format:Location start: 516"), 1) - self.assertEqual(errFD6_lines.count("INFO:Slither.Format:Location end: 528"), 1) - - def test_naming_convention_parameter(self): - errFD7 = open(self.testFilePath7+".err","r") - errFD7_lines = errFD7.readlines() - errFD7.close() - for i in range(len(errFD7_lines)): - errFD7_lines[i] = errFD7_lines[i].strip() - self.assertTrue(os.path.isfile(self.testFilePath7+".format"),"Patched .format file is not created?!") - self.assertEqual(errFD7_lines[0],"INFO:Slither.Format:Number of Slither results: 6") - self.assertEqual(errFD7_lines[1],"INFO:Slither.Format:Number of patches: 12") - self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Detector: naming-convention (parameter declaration)"), 6) - self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Detector: naming-convention (parameter uses)"), 6) - self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Old string: uint Count"), 3) - self.assertEqual(errFD7_lines.count("INFO:Slither.Format:New string: uint _Count"), 3) - self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location start: 91"), 1) - self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location end: 101"), 1) - self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location start: 215"), 1) - self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location end: 225"), 1) - self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Old string: Count"), 3) - self.assertEqual(errFD7_lines.count("INFO:Slither.Format:New string: _Count"), 3) - self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location start: 148"), 1) - self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location end: 153"), 1) - self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location start: 308"), 1) - self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location end: 313"), 1) - self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location start: 489"), 1) - self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location end: 499"), 1) - self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location start: 580"), 1) - self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location end: 585"), 1) - self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Old string: Count)"), 1) - self.assertEqual(errFD7_lines.count("INFO:Slither.Format:New string: _Count)"), 1) - self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location start: 506"), 1) - self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location end: 512"), 1) - self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Old string: uint Number"), 1) - self.assertEqual(errFD7_lines.count("INFO:Slither.Format:New string: uint _Number"), 1) - self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location start: 227"), 1) - self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location end: 238"), 1) - self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Old string: Number"), 1) - self.assertEqual(errFD7_lines.count("INFO:Slither.Format:New string: _Number"), 1) - self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location start: 314"), 1) - self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location end: 320"), 1) - self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Old string: address _to"), 1) - self.assertEqual(errFD7_lines.count("INFO:Slither.Format:New string: address _To"), 1) - self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location start: 708"), 1) - self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location end: 719"), 1) - self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Old string: address _from"), 1) - self.assertEqual(errFD7_lines.count("INFO:Slither.Format:New string: address _From"), 1) - self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location start: 721"), 1) - self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location end: 734"), 1) - self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Old string: _to"), 1) - self.assertEqual(errFD7_lines.count("INFO:Slither.Format:New string: _To"), 1) - self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location start: 811"), 1) - self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Location end: 814"), 1) - self.assertEqual(errFD7_lines.count("INFO:Slither.Format:Old string: _from"), 1, "Index variables of writes are not captured by node._expression_vars_read of Slither") - self.assertEqual(errFD7_lines.count("INFO:Slither.Format:New string: _From"), 1) - - def test_naming_convention_state_variable(self): - errFD8 = open(self.testFilePath8+".err","r") - errFD8_lines = errFD8.readlines() - errFD8.close() - for i in range(len(errFD8_lines)): - errFD8_lines[i] = errFD8_lines[i].strip() - self.assertTrue(os.path.isfile(self.testFilePath8+".format"),"Patched .format file is not created?!") - self.assertEqual(errFD8_lines[0],"INFO:Slither.Format:Number of Slither results: 3") - self.assertEqual(errFD8_lines[1],"INFO:Slither.Format:Number of patches: 9") - self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Detector: naming-convention (state variable declaration)"), 3) - self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Detector: naming-convention (state variable uses)"), 6) - self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Old string: number"), 3) - self.assertEqual(errFD8_lines.count("INFO:Slither.Format:New string: NUMBER"), 3) - self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Location start: 469"), 1) - self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Location end: 475"), 1) - self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Location start: 716"), 1) - self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Location end: 722"), 1) - self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Location start: 850"), 1) - self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Location end: 856"), 1) - self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Old string: Count"), 3) - self.assertEqual(errFD8_lines.count("INFO:Slither.Format:New string: count"), 3) - self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Location start: 547"), 1) - self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Location end: 552"), 1) - self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Location start: 725"), 1) - self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Location end: 730"), 1) - self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Location start: 745"), 1) - self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Location end: 750"), 1) - self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Old string: Maxnum"), 3) - self.assertEqual(errFD8_lines.count("INFO:Slither.Format:New string: maxnum"), 3) - self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Location start: 634"), 1) - self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Location end: 640"), 1) - self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Location start: 733"), 1) - self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Location end: 739"), 1) - self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Location start: 859"), 1) - self.assertEqual(errFD8_lines.count("INFO:Slither.Format:Location end: 865"), 1) - -if __name__ == '__main__': - unittest.main() diff --git a/slither/tools/slither_format/tests/test_pragma.py b/slither/tools/slither_format/tests/test_pragma.py deleted file mode 100644 index 70e0b7194..000000000 --- a/slither/tools/slither_format/tests/test_pragma.py +++ /dev/null @@ -1,71 +0,0 @@ -import unittest -import subprocess, os, sys - -class TestPragma(unittest.TestCase): - testDataDir = "./slither_format/tests/test_data/" - testDataFile1 = "pragma.0.4.24.sol" - testImportFile1 = "pragma.0.4.23.sol" - testFilePath1 = testDataDir+testDataFile1 - testImportFilePath1 = testDataDir+testImportFile1 - testDataFile2 = "pragma.0.5.4.sol" - testImportFile2 = "pragma.0.5.2.sol" - testFilePath2 = testDataDir+testDataFile2 - testImportFilePath2 = testDataDir+testImportFile2 - - def setUp(self): - outFD1 = open(self.testFilePath1+".out","w") - errFD1 = open(self.testFilePath1+".err","w") - p1 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose-test','--detect','pragma',self.testFilePath1], stdout=outFD1,stderr=errFD1) - p1.wait() - outFD1.close() - errFD1.close() - - outFD2 = open(self.testFilePath2+".out","w") - errFD2 = open(self.testFilePath2+".err","w") - my_env = os.environ.copy() - my_env["SOLC_VERSION"] = "0.5.4" - p2 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose-test','--detect','pragma',self.testFilePath2], stdout=outFD2,stderr=errFD2, env=my_env) - p2.wait() - outFD2.close() - errFD2.close() - - def tearDown(self): - p1 = subprocess.Popen(['rm','-f',self.testFilePath1+'.out',self.testFilePath1+'.err',self.testFilePath1+'.format',self.testImportFilePath1+'.format']) - p1.wait() - - p2 = subprocess.Popen(['rm','-f',self.testFilePath2+'.out',self.testFilePath2+'.err',self.testFilePath2+'.format',self.testImportFilePath2+'.format']) - p2.wait() - - def test_pragma(self): - errFD1 = open(self.testFilePath1+".err","r") - errFD1_lines = errFD1.readlines() - for i in range(len(errFD1_lines)): - errFD1_lines[i] = errFD1_lines[i].strip() - self.assertTrue(os.path.isfile(self.testFilePath1+".format"),"Patched .format file is not created?!") - self.assertEqual(errFD1_lines[0],"INFO:Slither.Format:Number of Slither results: 2") - self.assertEqual(errFD1_lines[1],"INFO:Slither.Format:Number of patches: 2") - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Detector: pragma"), 2) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Old string: pragma solidity ^0.4.23;"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Old string: pragma solidity ^0.4.24;"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:New string: pragma solidity 0.4.25;"), 2) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 0"), 2) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 24"), 2) - errFD1.close() - - errFD2 = open(self.testFilePath2+".err","r") - errFD2_lines = errFD2.readlines() - for i in range(len(errFD2_lines)): - errFD2_lines[i] = errFD2_lines[i].strip() - self.assertTrue(os.path.isfile(self.testFilePath2+".format"),"Patched .format file is not created?!") - self.assertEqual(errFD2_lines[0],"INFO:Slither.Format:Number of Slither results: 2") - self.assertEqual(errFD2_lines[1],"INFO:Slither.Format:Number of patches: 2") - self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Detector: pragma"), 2) - self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Old string: pragma solidity ^0.5.4;"), 1) - self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Old string: pragma solidity ^0.5.2;"), 1) - self.assertEqual(errFD2_lines.count("INFO:Slither.Format:New string: pragma solidity 0.5.3;"), 2) - self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Location start: 0"), 2) - self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Location end: 23"), 2) - errFD2.close() - -if __name__ == '__main__': - unittest.main() diff --git a/slither/tools/slither_format/tests/test_solc_version.py b/slither/tools/slither_format/tests/test_solc_version.py deleted file mode 100644 index 3f41f981e..000000000 --- a/slither/tools/slither_format/tests/test_solc_version.py +++ /dev/null @@ -1,116 +0,0 @@ -import unittest -import subprocess, os, sys - -class TestSolcVersion(unittest.TestCase): - testDataDir = "./slither_format/tests/test_data/" - testDataFile1 = "solc_version_incorrect1.sol" - testFilePath1 = testDataDir+testDataFile1 - testDataFile2 = "solc_version_incorrect2.sol" - testFilePath2 = testDataDir+testDataFile2 - testDataFile3 = "solc_version_incorrect3.sol" - testFilePath3 = testDataDir+testDataFile3 - testDataFile4 = "solc_version_incorrect4.sol" - testFilePath4 = testDataDir+testDataFile4 - - def setUp(self): - outFD1 = open(self.testFilePath1+".out","w") - errFD1 = open(self.testFilePath1+".err","w") - p1 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose-test','--detect','solc-version',self.testFilePath1], stdout=outFD1,stderr=errFD1) - p1.wait() - outFD1.close() - errFD1.close() - - outFD2 = open(self.testFilePath2+".out","w") - errFD2 = open(self.testFilePath2+".err","w") - p2 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose-test','--detect','solc-version',self.testFilePath2], stdout=outFD2,stderr=errFD2) - p2.wait() - outFD2.close() - errFD2.close() - - outFD3 = open(self.testFilePath3+".out","w") - errFD3 = open(self.testFilePath3+".err","w") - my_env = os.environ.copy() - my_env["SOLC_VERSION"] = "0.4.24" - p3 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose-test','--detect','solc-version',self.testFilePath3], stdout=outFD3,stderr=errFD3, env=my_env) - p3.wait() - outFD3.close() - errFD3.close() - - outFD4 = open(self.testFilePath4+".out","w") - errFD4 = open(self.testFilePath4+".err","w") - my_env = os.environ.copy() - my_env["SOLC_VERSION"] = "0.5.2" - p4 = subprocess.Popen(['python3', '-m', 'slither_format','--verbose-test','--detect','solc-version',self.testFilePath4], stdout=outFD4,stderr=errFD4, env=my_env) - p4.wait() - outFD4.close() - errFD4.close() - - def tearDown(self): - p1 = subprocess.Popen(['rm','-f',self.testFilePath1+'.out',self.testFilePath1+'.err',self.testFilePath1+'.format']) - p1.wait() - p2 = subprocess.Popen(['rm','-f',self.testFilePath2+'.out',self.testFilePath2+'.err',self.testFilePath2+'.format']) - p2.wait() - p3 = subprocess.Popen(['rm','-f',self.testFilePath3+'.out',self.testFilePath3+'.err',self.testFilePath3+'.format']) - p3.wait() - p4 = subprocess.Popen(['rm','-f',self.testFilePath4+'.out',self.testFilePath4+'.err',self.testFilePath4+'.format']) - p4.wait() - - def test_solc_version(self): - errFD1 = open(self.testFilePath1+".err","r") - errFD1_lines = errFD1.readlines() - for i in range(len(errFD1_lines)): - errFD1_lines[i] = errFD1_lines[i].strip() - self.assertTrue(os.path.isfile(self.testFilePath1+".format"),"Patched .format file is not created?!") - self.assertEqual(errFD1_lines[0],"INFO:Slither.Format:Number of Slither results: 1") - self.assertEqual(errFD1_lines[1],"INFO:Slither.Format:Number of patches: 1") - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Detector: solc-version"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Old string: pragma solidity ^0.4.23;"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:New string: pragma solidity 0.4.25;"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location start: 63"), 1) - self.assertEqual(errFD1_lines.count("INFO:Slither.Format:Location end: 87"), 1) - errFD1.close() - - errFD2 = open(self.testFilePath2+".err","r") - errFD2_lines = errFD2.readlines() - for i in range(len(errFD2_lines)): - errFD2_lines[i] = errFD2_lines[i].strip() - self.assertTrue(os.path.isfile(self.testFilePath2+".format"),"Patched .format file is not created?!") - self.assertEqual(errFD2_lines[0],"INFO:Slither.Format:Number of Slither results: 1") - self.assertEqual(errFD2_lines[1],"INFO:Slither.Format:Number of patches: 1") - self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Detector: solc-version"), 1) - self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Old string: pragma solidity >=0.4.0 <0.6.0;"), 1) - self.assertEqual(errFD2_lines.count("INFO:Slither.Format:New string: pragma solidity 0.5.3;"), 1) - self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Location start: 63"), 1) - self.assertEqual(errFD2_lines.count("INFO:Slither.Format:Location end: 94"), 1) - errFD2.close() - - errFD3 = open(self.testFilePath3+".err","r") - errFD3_lines = errFD3.readlines() - for i in range(len(errFD3_lines)): - errFD3_lines[i] = errFD3_lines[i].strip() - self.assertTrue(os.path.isfile(self.testFilePath3+".format"),"Patched .format file is not created?!") - self.assertEqual(errFD3_lines[0],"INFO:Slither.Format:Number of Slither results: 1") - self.assertEqual(errFD3_lines[1],"INFO:Slither.Format:Number of patches: 1") - self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Detector: solc-version"), 1) - self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Old string: pragma solidity >=0.4.0 <0.4.25;"), 1) - self.assertEqual(errFD3_lines.count("INFO:Slither.Format:New string: pragma solidity 0.4.25;"), 1) - self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Location start: 63"), 1) - self.assertEqual(errFD3_lines.count("INFO:Slither.Format:Location end: 95"), 1) - errFD3.close() - - errFD4 = open(self.testFilePath4+".err","r") - errFD4_lines = errFD4.readlines() - for i in range(len(errFD4_lines)): - errFD4_lines[i] = errFD4_lines[i].strip() - self.assertTrue(os.path.isfile(self.testFilePath4+".format"),"Patched .format file is not created?!") - self.assertEqual(errFD4_lines[0],"INFO:Slither.Format:Number of Slither results: 1") - self.assertEqual(errFD4_lines[1],"INFO:Slither.Format:Number of patches: 1") - self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Detector: solc-version"), 1) - self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Old string: pragma solidity ^0.5.1;"), 1) - self.assertEqual(errFD4_lines.count("INFO:Slither.Format:New string: pragma solidity 0.5.3;"), 1) - self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location start: 63"), 1) - self.assertEqual(errFD4_lines.count("INFO:Slither.Format:Location end: 86"), 1) - errFD4.close() - -if __name__ == '__main__': - unittest.main() diff --git a/slither/tools/slither_format/tests/test_unicode.py b/slither/tools/slither_format/tests/test_unicode.py deleted file mode 100644 index dcfeb11ca..000000000 --- a/slither/tools/slither_format/tests/test_unicode.py +++ /dev/null @@ -1,37 +0,0 @@ -import unittest -import subprocess, os, sys - -class TestUnicode(unittest.TestCase): - testDataFile = "unicode.sol" - testDataDir = "./slither_format/tests/test_data/" - testFilePath = testDataDir+testDataFile - - def setUp(self): - outFD = open(self.testFilePath+".out","w") - errFD = open(self.testFilePath+".err","w") - p = subprocess.Popen(['python3', '-m', 'slither_format','--verbose-test',self.testFilePath], stdout=outFD,stderr=errFD) - p.wait() - outFD.close() - errFD.close() - - def tearDown(self): - p = subprocess.Popen(['rm','-f',self.testFilePath+'.out',self.testFilePath+'.err',self.testFilePath+'.format']) - p.wait() - - def test_constable_states(self): - errFD = open(self.testFilePath+".err","r") - errFD_lines = errFD.readlines() - for i in range(len(errFD_lines)): - errFD_lines[i] = errFD_lines[i].strip() - self.assertTrue(os.path.isfile(self.testFilePath+".format"),"Patched .format file is not created?!") - self.assertEqual(errFD_lines[0].rstrip(),"INFO:Slither.Format:Number of Slither results: 1") - self.assertEqual(errFD_lines[1].rstrip(),"INFO:Slither.Format:Number of patches: 1") - self.assertEqual(errFD_lines.count("INFO:Slither.Format:Detector: constable-states"), 1) - self.assertEqual(errFD_lines.count("INFO:Slither.Format:Old string: uint sv"), 1) - self.assertEqual(errFD_lines.count("INFO:Slither.Format:New string: uint constant sv"), 1) - self.assertEqual(errFD_lines.count("INFO:Slither.Format:Location start: 23"), 1) - self.assertEqual(errFD_lines.count("INFO:Slither.Format:Location end: 30"), 1) - errFD.close() - -if __name__ == '__main__': - unittest.main() diff --git a/slither/tools/slither_format/tests/test_unused_state_vars.py b/slither/tools/slither_format/tests/test_unused_state_vars.py deleted file mode 100644 index c5ec2011e..000000000 --- a/slither/tools/slither_format/tests/test_unused_state_vars.py +++ /dev/null @@ -1,37 +0,0 @@ -import unittest -import subprocess, os, sys - -class TestUnusedStateVars(unittest.TestCase): - testDataFile = "unused_state.sol" - testDataDir = "./slither_format/tests/test_data/" - testFilePath = testDataDir+testDataFile - - def setUp(self): - outFD = open(self.testFilePath+".out","w") - errFD = open(self.testFilePath+".err","w") - p = subprocess.Popen(['python3', '-m', 'slither_format','--verbose-test','--detect','unused-state',self.testFilePath], stdout=outFD,stderr=errFD) - p.wait() - outFD.close() - errFD.close() - - def tearDown(self): - p = subprocess.Popen(['rm','-f',self.testFilePath+'.out',self.testFilePath+'.err',self.testFilePath+'.format']) - p.wait() - - def test_unused_state_vars(self): - errFD = open(self.testFilePath+".err","r") - errFD_lines = errFD.readlines() - for i in range(len(errFD_lines)): - errFD_lines[i] = errFD_lines[i].strip() - self.assertTrue(os.path.isfile(self.testFilePath+".format"),"Patched .format file is not created?!") - self.assertEqual(errFD_lines[0].rstrip(),"INFO:Slither.Format:Number of Slither results: 1") - self.assertEqual(errFD_lines[1].rstrip(),"INFO:Slither.Format:Number of patches: 1") - self.assertEqual(errFD_lines.count("INFO:Slither.Format:Detector: unused-state"), 1) - self.assertEqual(errFD_lines.count("INFO:Slither.Format:Old string: address unused ;"), 1) - self.assertEqual(errFD_lines.count("INFO:Slither.Format:New string:"), 1) - self.assertEqual(errFD_lines.count("INFO:Slither.Format:Location start: 44"), 1) - self.assertEqual(errFD_lines.count("INFO:Slither.Format:Location end: 63"), 1) - errFD.close() - -if __name__ == '__main__': - unittest.main() From 2d82c6f0ea3abad22083ffec9b5d602e69ce1bcf Mon Sep 17 00:00:00 2001 From: Feist Josselin Date: Wed, 2 Oct 2019 16:05:21 +0200 Subject: [PATCH 178/223] Update setup.py --- setup.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.py b/setup.py index 3031a8de3..52d8d9d95 100644 --- a/setup.py +++ b/setup.py @@ -5,7 +5,7 @@ setup( description='Slither is a Solidity static analysis framework written in Python 3.', url='https://github.com/crytic/slither', author='Trail of Bits', - version='0.6.4', + version='0.6.6', packages=find_packages(), python_requires='>=3.6', install_requires=['prettytable>=0.7.2', From b9ec9b1e8db2147a161cf80ef1dfd4c6a9ba4bca Mon Sep 17 00:00:00 2001 From: Josselin Date: Wed, 2 Oct 2019 16:08:27 +0200 Subject: [PATCH 179/223] Remove unused visitor --- .../visitors/expression/read_var_syntactic.py | 105 ------------------ 1 file changed, 105 deletions(-) delete mode 100644 slither/visitors/expression/read_var_syntactic.py diff --git a/slither/visitors/expression/read_var_syntactic.py b/slither/visitors/expression/read_var_syntactic.py deleted file mode 100644 index 92cfd4ae9..000000000 --- a/slither/visitors/expression/read_var_syntactic.py +++ /dev/null @@ -1,105 +0,0 @@ - -from slither.visitors.expression.expression import ExpressionVisitor - -from slither.core.expressions.assignment_operation import AssignmentOperationType - -from slither.core.variables.variable import Variable -from slither.core.declarations.solidity_variables import SolidityVariable - -key = 'ReadVarSyntactic' - -def get(expression): - val = expression.context[key] - # we delete the item to reduce memory use - del expression.context[key] - return val - -def set_val(expression, val): - expression.context[key] = val - -# This Visitor is similar to ReadVar -# Except that it does explore all assignements operations -# Read is in the context of source code read, rather than semantic-based read -class ReadVarSyntactic(ExpressionVisitor): - - def result(self): - if self._result is None: - self._result = list(set(get(self.expression))) - return self._result - - - def _post_assignement_operation(self, expression): - left = get(expression.expression_left) - right = get(expression.expression_right) - val = left + right - set_val(expression, val) - - def _post_binary_operation(self, expression): - left = get(expression.expression_left) - right = get(expression.expression_right) - val = left + right - set_val(expression, val) - - def _post_call_expression(self, expression): - called = get(expression.called) - args = [get(a) for a in expression.arguments if a] - args = [item for sublist in args for item in sublist] - val = called + args - set_val(expression, val) - - def _post_conditional_expression(self, expression): - if_expr = get(expression.if_expression) - else_expr = get(expression.else_expression) - then_expr = get(expression.then_expression) - val = if_expr + else_expr + then_expr - set_val(expression, val) - - def _post_elementary_type_name_expression(self, expression): - set_val(expression, []) - - # save only identifier expression - def _post_identifier(self, expression): - if isinstance(expression.value, Variable): - set_val(expression, [expression]) - elif isinstance(expression.value, SolidityVariable): - set_val(expression, [expression]) - else: - set_val(expression, []) - - def _post_index_access(self, expression): - left = get(expression.expression_left) - right = get(expression.expression_right) - val = left + right + [expression] - set_val(expression, val) - - def _post_literal(self, expression): - set_val(expression, []) - - def _post_member_access(self, expression): - expr = get(expression.expression) - val = expr - set_val(expression, val) - - def _post_new_array(self, expression): - set_val(expression, []) - - def _post_new_contract(self, expression): - set_val(expression, []) - - def _post_new_elementary_type(self, expression): - set_val(expression, []) - - def _post_tuple_expression(self, expression): - expressions = [get(e) for e in expression.expressions if e] - val = [item for sublist in expressions for item in sublist] - set_val(expression, val) - - def _post_type_conversion(self, expression): - expr = get(expression.expression) - val = expr - set_val(expression, val) - - def _post_unary_operation(self, expression): - expr = get(expression.expression) - val = expr - set_val(expression, val) From 9db6f4396eefc467de0470547767c1639d642945 Mon Sep 17 00:00:00 2001 From: Josselin Date: Thu, 3 Oct 2019 08:40:31 +0200 Subject: [PATCH 180/223] Fix incorrect flattening --- slither/tools/flattening/flattening.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/slither/tools/flattening/flattening.py b/slither/tools/flattening/flattening.py index 6acd8200a..ccf398009 100644 --- a/slither/tools/flattening/flattening.py +++ b/slither/tools/flattening/flattening.py @@ -121,7 +121,8 @@ class Flattening: self._export_contract(ir.contract_created, exported, list_contract) if isinstance(ir, TypeConversion): self._export_from_type(ir.type, contract, exported, list_contract) - + if contract.name in exported: + return exported.add(contract.name) list_contract.append(self._source_codes[contract]) @@ -142,14 +143,15 @@ class Flattening: if not self.DEFAULT_EXPORT_PATH.exists(): self.DEFAULT_EXPORT_PATH.mkdir(parents=True) - ret = [] if target is None: for contract in self._slither.contracts_derived: + ret = [] self._export(contract, ret) else: contract = self._slither.get_contract_from_name(target) if contract is None: logger.error(f'{target} not found') else: + ret = [] self._export(contract, ret) From 0d0a77a740ab1ec16bffdfb2fa016db2267ceda7 Mon Sep 17 00:00:00 2001 From: Josselin Date: Thu, 3 Oct 2019 09:08:45 +0200 Subject: [PATCH 181/223] Add node_initalization to state variable Improve echidna printer --- slither/core/variables/state_variable.py | 23 +++++++++++ slither/printers/guidance/echidna.py | 38 ++++++++++++++----- slither/solc_parsing/declarations/contract.py | 4 ++ 3 files changed, 56 insertions(+), 9 deletions(-) diff --git a/slither/core/variables/state_variable.py b/slither/core/variables/state_variable.py index 8cebc8758..af5421c53 100644 --- a/slither/core/variables/state_variable.py +++ b/slither/core/variables/state_variable.py @@ -4,6 +4,9 @@ from slither.utils.type import export_nested_types_from_variable class StateVariable(ChildContract, Variable): + def __init__(self): + super(StateVariable, self).__init__() + self._node_initialization = None def is_declared_by(self, contract): """ @@ -61,4 +64,24 @@ class StateVariable(ChildContract, Variable): # endregion ################################################################################### ################################################################################### + # region IRs (initialization) + ################################################################################### + ################################################################################### + + @property + def node_initialization(self): + """ + Node for the state variable initalization + :return: + """ + return self._node_initialization + + @node_initialization.setter + def node_initialization(self, node_initialization): + self._node_initialization = node_initialization + + + # endregion + ################################################################################### + ################################################################################### diff --git a/slither/printers/guidance/echidna.py b/slither/printers/guidance/echidna.py index ed2b79d2e..1413a765e 100644 --- a/slither/printers/guidance/echidna.py +++ b/slither/printers/guidance/echidna.py @@ -6,7 +6,7 @@ from collections import defaultdict from slither.printers.abstract_printer import AbstractPrinter from slither.core.declarations.solidity_variables import SolidityVariableComposed, SolidityFunction from slither.slithir.operations.binary import Binary, BinaryType - +from slither.core.variables.state_variable import StateVariable from slither.slithir.variables import Constant @@ -53,6 +53,26 @@ def _extract_assert(slither): ret[contract.name] = functions_using_assert return ret +def _extract_constants_from_irs(irs, all_cst_used, all_cst_used_in_binary, context_explored): + for ir in irs: + if isinstance(ir, Binary): + for r in ir.read: + if isinstance(r, Constant): + all_cst_used_in_binary[BinaryType.str(ir.type)].append(r.value) + for r in ir.read: + if isinstance(r, Constant): + all_cst_used.append(r.value) + if isinstance(r, StateVariable): + if r.node_initialization: + if r.node_initialization.irs: + if r.node_initialization in context_explored: + continue + else: + context_explored.add(r.node_initialization) + _extract_constants_from_irs(r.node_initialization.irs, + all_cst_used, + all_cst_used_in_binary, + context_explored) def _extract_constants(slither): ret_cst_used = defaultdict(dict) @@ -61,14 +81,14 @@ def _extract_constants(slither): for function in contract.functions_entry_points: all_cst_used = [] all_cst_used_in_binary = defaultdict(list) - for ir in function.all_slithir_operations(): - if isinstance(ir, Binary): - for r in ir.read: - if isinstance(r, Constant): - all_cst_used_in_binary[BinaryType.str(ir.type)].append(r.value) - for r in ir.read: - if isinstance(r, Constant): - all_cst_used.append(r.value) + + context_explored = set() + context_explored.add(function) + _extract_constants_from_irs(function.all_slithir_operations(), + all_cst_used, + all_cst_used_in_binary, + context_explored) + if all_cst_used: ret_cst_used[contract.name][function.full_name] = all_cst_used if all_cst_used_in_binary: diff --git a/slither/solc_parsing/declarations/contract.py b/slither/solc_parsing/declarations/contract.py index ebb43a185..b1c4cd83c 100644 --- a/slither/solc_parsing/declarations/contract.py +++ b/slither/solc_parsing/declarations/contract.py @@ -402,10 +402,12 @@ class ContractSolc04(Contract): self._functions[constructor_variable.canonical_name] = constructor_variable prev_node = self._create_node(constructor_variable, 0, variable_candidate) + variable_candidate.node_initialization = prev_node counter = 1 for v in self.state_variables[idx+1:]: if v.expression and not v.is_constant: next_node = self._create_node(constructor_variable, counter, v) + v.node_initialization = next_node prev_node.add_son(next_node) next_node.add_father(prev_node) counter += 1 @@ -425,10 +427,12 @@ class ContractSolc04(Contract): self._functions[constructor_variable.canonical_name] = constructor_variable prev_node = self._create_node(constructor_variable, 0, variable_candidate) + variable_candidate.node_initialization = prev_node counter = 1 for v in self.state_variables[idx+1:]: if v.expression and v.is_constant: next_node = self._create_node(constructor_variable, counter, v) + v.node_initialization = next_node prev_node.add_son(next_node) next_node.add_father(prev_node) counter += 1 From c723e289809625cae7736449a9315d3710d3022c Mon Sep 17 00:00:00 2001 From: Josselin Date: Fri, 4 Oct 2019 09:54:52 +0200 Subject: [PATCH 182/223] Add function.shadows property Fix incorrect inheritance order Improve inheritance graph printer: - fix incorrect inheritance collision - do not print constructor variables functions --- slither/core/declarations/contract.py | 2 +- slither/core/declarations/function.py | 9 ++ .../printers/inheritance/inheritance_graph.py | 32 ++--- slither/printers/summary/slithir.py | 2 +- slither/solc_parsing/declarations/contract.py | 5 +- .../expressions/expression_parsing.py | 8 +- slither/utils/inheritance_analysis.py | 112 ++---------------- 7 files changed, 38 insertions(+), 132 deletions(-) diff --git a/slither/core/declarations/contract.py b/slither/core/declarations/contract.py index 20a8f3f8e..23317c6ce 100644 --- a/slither/core/declarations/contract.py +++ b/slither/core/declarations/contract.py @@ -386,7 +386,7 @@ class Contract(ChildSlither, SourceMapping): accessible_elements = {} contracts_visited = [] for father in self.inheritance_reverse: - functions = {v.full_name: v for (_, v) in getter_available(father) + functions = {v.full_name: v for (v) in getter_available(father) if not v.contract in contracts_visited} contracts_visited.append(father) inherited_elements.update(functions) diff --git a/slither/core/declarations/function.py b/slither/core/declarations/function.py index 8977a9b89..11d39dc92 100644 --- a/slither/core/declarations/function.py +++ b/slither/core/declarations/function.py @@ -126,6 +126,7 @@ class Function(ChildContract, ChildInheritance, SourceMapping): self._all_solidity_variables_used_as_args = None self._is_shadowed = False + self._shadows = False # set(ReacheableNode) self._reachable_from_nodes = set() @@ -316,6 +317,14 @@ class Function(ChildContract, ChildInheritance, SourceMapping): def is_shadowed(self, is_shadowed): self._is_shadowed = is_shadowed + @property + def shadows(self): + return self._shadows + + @shadows.setter + def shadows(self, _shadows): + self._shadows = _shadows + # endregion ################################################################################### ################################################################################### diff --git a/slither/printers/inheritance/inheritance_graph.py b/slither/printers/inheritance/inheritance_graph.py index 73ee72af8..4dbed9e0b 100644 --- a/slither/printers/inheritance/inheritance_graph.py +++ b/slither/printers/inheritance/inheritance_graph.py @@ -10,7 +10,6 @@ from slither.core.declarations.contract import Contract from slither.core.solidity_types.user_defined_type import UserDefinedType from slither.printers.abstract_printer import AbstractPrinter from slither.utils.inheritance_analysis import (detect_c3_function_shadowing, - detect_function_shadowing, detect_state_variable_shadowing) @@ -26,19 +25,6 @@ class PrinterInheritanceGraph(AbstractPrinter): inheritance = [x.inheritance for x in slither.contracts] self.inheritance = set([item for sublist in inheritance for item in sublist]) - # Create a lookup of direct shadowing instances. - self.direct_overshadowing_functions = {} - shadows = detect_function_shadowing(slither.contracts, True, False) - for overshadowing_instance in shadows: - overshadowing_function = overshadowing_instance[2] - - # Add overshadowing function entry. - if overshadowing_function not in self.direct_overshadowing_functions: - self.direct_overshadowing_functions[overshadowing_function] = set() - self.direct_overshadowing_functions[overshadowing_function].add(overshadowing_instance) - - # Create a lookup of shadowing state variables. - # Format: { colliding_variable : set([colliding_variables]) } self.overshadowing_state_variables = {} shadows = detect_state_variable_shadowing(slither.contracts) for overshadowing_instance in shadows: @@ -55,7 +41,7 @@ class PrinterInheritanceGraph(AbstractPrinter): func_name = func.full_name pattern = ' %s' pattern_shadow = ' %s' - if func in self.direct_overshadowing_functions: + if func.shadows: return pattern_shadow % func_name return pattern % func_name @@ -89,12 +75,10 @@ class PrinterInheritanceGraph(AbstractPrinter): # If this variable is an overshadowing variable, we'll want to return information describing it. result = [] indirect_shadows = detect_c3_function_shadowing(contract) - if indirect_shadows: - for collision_set in sorted(indirect_shadows, key=lambda x: x[0][1].name): - winner = collision_set[-1][1].contract_declarer.name - collision_steps = [colliding_function.contract_declarer.name for _, colliding_function in collision_set] - collision_steps = ', '.join(collision_steps) - result.append(f"'{collision_set[0][1].full_name}' collides in inherited contracts {collision_steps} where {winner} is chosen.") + for winner, colliding_functions in indirect_shadows.items(): + collision_steps = ', '.join([f.contract_declarer.name + for f in colliding_functions] + [winner.contract_declarer.name]) + result.append(f"'{winner.full_name}' collides in inherited contracts {collision_steps} where {winner.contract_declarer.name} is chosen.") return '\n'.join(result) def _get_port_id(self, var, contract): @@ -116,10 +100,12 @@ class PrinterInheritanceGraph(AbstractPrinter): # Functions visibilities = ['public', 'external'] public_functions = [self._get_pattern_func(f, contract) for f in contract.functions if - not f.is_constructor and f.contract_declarer == contract and f.visibility in visibilities] + not f.is_constructor and not f.is_constructor_variables + and f.contract_declarer == contract and f.visibility in visibilities] public_functions = ''.join(public_functions) private_functions = [self._get_pattern_func(f, contract) for f in contract.functions if - not f.is_constructor and f.contract_declarer == contract and f.visibility not in visibilities] + not f.is_constructor and not f.is_constructor_variables + and f.contract_declarer == contract and f.visibility not in visibilities] private_functions = ''.join(private_functions) # Modifiers diff --git a/slither/printers/summary/slithir.py b/slither/printers/summary/slithir.py index 4e936e038..70696c6fa 100644 --- a/slither/printers/summary/slithir.py +++ b/slither/printers/summary/slithir.py @@ -23,7 +23,7 @@ class PrinterSlithIR(AbstractPrinter): for contract in self.contracts: print('Contract {}'.format(contract.name)) for function in contract.functions: - print(f'\tFunction {function.canonical_name}') + print(f'\tFunction {function.canonical_name} {"" if function.is_shadowed else "(*)"}') for node in function.nodes: if node.expression: print('\t\tExpression: {}'.format(node.expression)) diff --git a/slither/solc_parsing/declarations/contract.py b/slither/solc_parsing/declarations/contract.py index b1c4cd83c..b667d51f1 100644 --- a/slither/solc_parsing/declarations/contract.py +++ b/slither/solc_parsing/declarations/contract.py @@ -290,7 +290,7 @@ class ContractSolc04(Contract): elements_no_params = self._modifiers_no_params getter = lambda f: f.modifiers - getter_available = lambda f: f.available_modifiers_as_dict().items() + getter_available = lambda f: f.modifiers_declared Cls = ModifierSolc self._modifiers = self._analyze_params_elements(elements_no_params, getter, getter_available, Cls) @@ -302,7 +302,7 @@ class ContractSolc04(Contract): elements_no_params = self._functions_no_params getter = lambda f: f.functions - getter_available = lambda f: f.available_functions_as_dict().items() + getter_available = lambda f: f.functions_declared Cls = FunctionSolc self._functions = self._analyze_params_elements(elements_no_params, getter, getter_available, Cls) @@ -354,6 +354,7 @@ class ContractSolc04(Contract): for element in all_elements.values(): if accessible_elements[element.full_name] != all_elements[element.canonical_name]: element.is_shadowed = True + accessible_elements[element.full_name].shadows = True return all_elements diff --git a/slither/solc_parsing/expressions/expression_parsing.py b/slither/solc_parsing/expressions/expression_parsing.py index dc565c574..a3d48c7f2 100644 --- a/slither/solc_parsing/expressions/expression_parsing.py +++ b/slither/solc_parsing/expressions/expression_parsing.py @@ -117,18 +117,18 @@ def find_variable(var_name, caller_context, referenced_declaration=None, is_supe return conc_variables_ptr[var_name] if is_super: - getter_available = lambda f: f.available_functions_as_dict().items() + getter_available = lambda f: f.functions_declared d = {f.canonical_name:f for f in contract.functions} - functions = {f.full_name:f for f in contract.available_elements_from_inheritances(d, getter_available).values()} + functions = {f.full_name:f for f in contract_declarer.available_elements_from_inheritances(d, getter_available).values()} else: functions = contract.available_functions_as_dict() if var_name in functions: return functions[var_name] if is_super: - getter_available = lambda m: m.available_modifiers_as_dict().items() + getter_available = lambda m: m.modifiers_declared d = {m.canonical_name: m for m in contract.modifiers} - modifiers = {m.full_name: m for m in contract.available_elements_from_inheritances(d, getter_available).values()} + modifiers = {m.full_name: m for m in contract_declarer.available_elements_from_inheritances(d, getter_available).values()} else: modifiers = contract.available_modifiers_as_dict() if var_name in modifiers: diff --git a/slither/utils/inheritance_analysis.py b/slither/utils/inheritance_analysis.py index 013de531e..11f6e19d7 100644 --- a/slither/utils/inheritance_analysis.py +++ b/slither/utils/inheritance_analysis.py @@ -2,6 +2,7 @@ Detects various properties of inheritance in provided contracts. """ +from collections import defaultdict def detect_c3_function_shadowing(contract): """ @@ -9,112 +10,21 @@ def detect_c3_function_shadowing(contract): properties, despite not directly inheriting from each other. :param contract: The contract to check for potential C3 linearization shadowing within. - :return: A list of list of tuples: (contract, function), where each inner list describes colliding functions. - The later elements in the inner list overshadow the earlier ones. The contract-function pair's function does not - need to be defined in its paired contract, it may have been inherited within it. + :return: A dict (function winner -> [shadowed functions]) """ - # Loop through all contracts, and all underlying functions. - results = {} - for i in range(0, len(contract.immediate_inheritance) - 1): - inherited_contract1 = contract.immediate_inheritance[i] + targets = {f.full_name:f for f in contract.functions_inherited if f.shadows and not f.is_constructor + and not f.is_constructor_variables} - for function1 in inherited_contract1.functions_and_modifiers_declared: - # If this function has already be handled or is unimplemented, we skip it - if function1.full_name in results or function1.is_constructor or not function1.is_implemented: - continue - - # Define our list of function instances which overshadow each other. - functions_matching = [(inherited_contract1, function1)] - already_processed = set([function1]) - - # Loop again through other contracts and functions to compare to. - for x in range(i + 1, len(contract.immediate_inheritance)): - inherited_contract2 = contract.immediate_inheritance[x] - - # Loop for each function in this contract - for function2 in inherited_contract2.functions_and_modifiers: - # Skip this function if it is the last function that was shadowed. - if function2 in already_processed or function2.is_constructor or not function2.is_implemented: - continue - - # If this function does have the same full name, it is shadowing through C3 linearization. - if function1.full_name == function2.full_name: - functions_matching.append((inherited_contract2, function2)) - already_processed.add(function2) - - # If we have more than one definition matching the same signature, we add it to the results. - if len(functions_matching) > 1: - results[function1.full_name] = functions_matching - - return list(results.values()) + collisions = defaultdict(set) - -def detect_direct_function_shadowing(contract): - """ - Detects and obtains functions which are shadowed immediately by the provided ancestor contract. - :param contract: The ancestor contract which we check for function shadowing within. - :return: A list of tuples (overshadowing_function, overshadowed_immediate_base_contract, overshadowed_function) - -overshadowing_function is the function defined within the provided contract that overshadows another - definition. - -overshadowed_immediate_base_contract is the immediate inherited-from contract that provided the shadowed - function (could have provided it through inheritance, does not need to directly define it). - -overshadowed_function is the function definition which is overshadowed by the provided contract's definition. - """ - functions_declared = {function.full_name: function for function in contract.functions_and_modifiers_declared} - results = {} - for base_contract in reversed(contract.immediate_inheritance): - for base_function in base_contract.functions_and_modifiers: - - # We already found the most immediate shadowed definition for this function, skip to the next. - if base_function.full_name in results: + for contract_inherited in contract.immediate_inheritance: + for candidate in contract_inherited.functions: + if candidate.full_name not in targets or candidate.is_shadowed: continue - - # If this function is implemented and it collides with a definition in our immediate contract, we add - # it to our results. - if base_function.is_implemented and base_function.full_name in functions_declared: - results[base_function.full_name] = (functions_declared[base_function.full_name], base_contract, base_function) - - return list(results.values()) - - -def detect_function_shadowing(contracts, direct_shadowing=True, indirect_shadowing=True): - """ - Detects all overshadowing and overshadowed functions in the provided contracts. - :param contracts: The contracts to detect shadowing within. - :param direct_shadowing: Include results from direct inheritance/inheritance ancestry. - :param indirect_shadowing: Include results from indirect inheritance collisions as a result of multiple - inheritance/c3 linearization. - :return: Returns a set of tuples(contract_scope, overshadowing_contract, overshadowing_function, - overshadowed_contract, overshadowed_function), where: - -The contract_scope defines where the detection of shadowing is most immediately found. - -For each contract-function pair, contract is the first contract where the function is seen, while the function - refers to the actual definition. The function does not need to be defined in the contract (could be inherited). - """ - results = set() - for contract in contracts: - - # Detect immediate inheritance shadowing. - if direct_shadowing: - shadows = detect_direct_function_shadowing(contract) - for (overshadowing_function, overshadowed_base_contract, overshadowed_function) in shadows: - results.add((contract, contract, overshadowing_function, overshadowed_base_contract, - overshadowed_function)) - - # Detect c3 linearization shadowing (multi inheritance shadowing). - if indirect_shadowing: - shadows = detect_c3_function_shadowing(contract) - for colliding_functions in shadows: - for x in range(0, len(colliding_functions) - 1): - for y in range(x + 1, len(colliding_functions)): - # The same function definition can appear more than once in the inheritance chain, - # overshadowing items between, so it is important to remember to filter it out here. - if colliding_functions[y][1].contract_declarer != colliding_functions[x][1].contract_declarer: - results.add((contract, colliding_functions[y][0], colliding_functions[y][1], - colliding_functions[x][0], colliding_functions[x][1])) - - return results - + if targets[candidate.full_name].canonical_name != candidate.canonical_name: + collisions[targets[candidate.full_name]].add(candidate) + return collisions def detect_state_variable_shadowing(contracts): """ From 3151cd0b9984dfc7d53eb54cfb038fcf266ef950 Mon Sep 17 00:00:00 2001 From: Josselin Date: Fri, 4 Oct 2019 17:24:17 +0200 Subject: [PATCH 183/223] Update crytic-compile dep to 0.1.4 --- setup.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/setup.py b/setup.py index fec1779be..2c32f821b 100644 --- a/setup.py +++ b/setup.py @@ -10,8 +10,8 @@ setup( python_requires='>=3.6', install_requires=['prettytable>=0.7.2', 'pysha3>=1.0.2', - 'crytic-compile'], - dependency_links=['git+https://github.com/crytic/crytic-compile.git@master#egg=crytic-compile'], + 'crytic-compile>=0.1.4'], +# dependency_links=['git+https://github.com/crytic/crytic-compile.git@master#egg=crytic-compile'], license='AGPL-3.0', long_description=open('README.md').read(), entry_points={ From 010c159242d1869f3a75043b236a3e4776f52d27 Mon Sep 17 00:00:00 2001 From: Josselin Date: Fri, 4 Oct 2019 17:38:37 +0200 Subject: [PATCH 184/223] Update documentation --- README.md | 28 +++++++++++++++------------- slither/printers/guidance/echidna.py | 2 +- 2 files changed, 16 insertions(+), 14 deletions(-) diff --git a/README.md b/README.md index 846b8c6eb..063cc6d33 100644 --- a/README.md +++ b/README.md @@ -90,19 +90,21 @@ Num | Printer | Description --- | --- | --- 1 | `call-graph` | [Export the call-graph of the contracts to a dot file](https://github.com/trailofbits/slither/wiki/Printer-documentation#call-graph) 2 | `cfg` | [Export the CFG of each functions](https://github.com/trailofbits/slither/wiki/Printer-documentation#cfg) -3 | `contract-summary` | [Print a summary of the contracts](https://github.com/trailofbits/slither/wiki/Printer-documentation#contract-summary) -4 | `data-dependency` | [Print the data dependencies of the variables](https://github.com/trailofbits/slither/wiki/Printer-documentation#data-dependencies) -5 | `function-id` | [Print the keccack256 signature of the functions](https://github.com/trailofbits/slither/wiki/Printer-documentation#function-id) -6 | `function-summary` | [Print a summary of the functions](https://github.com/trailofbits/slither/wiki/Printer-documentation#function-summary) -7 | `human-summary` | [Print a human-readable summary of the contracts](https://github.com/trailofbits/slither/wiki/Printer-documentation#human-summary) -8 | `inheritance` | [Print the inheritance relations between contracts](https://github.com/trailofbits/slither/wiki/Printer-documentation#inheritance) -9 | `inheritance-graph` | [Export the inheritance graph of each contract to a dot file](https://github.com/trailofbits/slither/wiki/Printer-documentation#inheritance-graph) -10 | `modifiers` | [Print the modifiers called by each function](https://github.com/trailofbits/slither/wiki/Printer-documentation#modifiers) -11 | `require` | [Print the require and assert calls of each function](https://github.com/trailofbits/slither/wiki/Printer-documentation#require) -12 | `slithir` | [Print the slithIR representation of the functions](https://github.com/trailofbits/slither/wiki/Printer-documentation#slithir) -13 | `slithir-ssa` | [Print the slithIR representation of the functions](https://github.com/trailofbits/slither/wiki/Printer-documentation#slithir-ssa) -14 | `variable-order` | [Print the storage order of the state variables](https://github.com/trailofbits/slither/wiki/Printer-documentation#variable-order) -15 | `vars-and-auth` | [Print the state variables written and the authorization of the functions](https://github.com/trailofbits/slither/wiki/Printer-documentation#variables-written-and-authorization) +3 | `constructor-calls` | [Print the constructors executed](https://github.com/crytic/slither/wiki/Printer-documentation#constructor-calls) +4 | `contract-summary` | [Print a summary of the contracts](https://github.com/trailofbits/slither/wiki/Printer-documentation#contract-summary) +5 | `data-dependency` | [Print the data dependencies of the variables](https://github.com/trailofbits/slither/wiki/Printer-documentation#data-dependencies) +6 | `echidna` | [Export Echidna guiding information](https://github.com/trailofbits/slither/wiki/Printer-documentation#echidna) +7 | `function-id` | [Print the keccack256 signature of the functions](https://github.com/trailofbits/slither/wiki/Printer-documentation#function-id) +8 | `function-summary` | [Print a summary of the functions](https://github.com/trailofbits/slither/wiki/Printer-documentation#function-summary) +9 | `human-summary` | [Print a human-readable summary of the contracts](https://github.com/trailofbits/slither/wiki/Printer-documentation#human-summary) +10 | `inheritance` | [Print the inheritance relations between contracts](https://github.com/trailofbits/slither/wiki/Printer-documentation#inheritance) +11 | `inheritance-graph` | [Export the inheritance graph of each contract to a dot file](https://github.com/trailofbits/slither/wiki/Printer-documentation#inheritance-graph) +12 | `modifiers` | [Print the modifiers called by each function](https://github.com/trailofbits/slither/wiki/Printer-documentation#modifiers) +13 | `require` | [Print the require and assert calls of each function](https://github.com/trailofbits/slither/wiki/Printer-documentation#require) +14 | `slithir` | [Print the slithIR representation of the functions](https://github.com/trailofbits/slither/wiki/Printer-documentation#slithir) +15 | `slithir-ssa` | [Print the slithIR representation of the functions](https://github.com/trailofbits/slither/wiki/Printer-documentation#slithir-ssa) +16 | `variable-order` | [Print the storage order of the state variables](https://github.com/trailofbits/slither/wiki/Printer-documentation#variable-order) +17 | `vars-and-auth` | [Print the state variables written and the authorization of the functions](https://github.com/trailofbits/slither/wiki/Printer-documentation#variables-written-and-authorization) ## How to install diff --git a/slither/printers/guidance/echidna.py b/slither/printers/guidance/echidna.py index 1413a765e..288a4d1f5 100644 --- a/slither/printers/guidance/echidna.py +++ b/slither/printers/guidance/echidna.py @@ -100,7 +100,7 @@ def _extract_constants(slither): class Echidna(AbstractPrinter): ARGUMENT = 'echidna' - HELP = 'todo' + HELP = 'Export Echidna guiding information' WIKI = 'https://github.com/trailofbits/slither/wiki/Printer-documentation#echidna' From 60eb2f1c9302ae924c764b381b7155afbec2b0a1 Mon Sep 17 00:00:00 2001 From: Josselin Date: Fri, 4 Oct 2019 17:39:24 +0200 Subject: [PATCH 185/223] 0.6.7 --- setup.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.py b/setup.py index 2c32f821b..2fd078d92 100644 --- a/setup.py +++ b/setup.py @@ -5,7 +5,7 @@ setup( description='Slither is a Solidity static analysis framework written in Python 3.', url='https://github.com/crytic/slither', author='Trail of Bits', - version='0.6.6', + version='0.6.7', packages=find_packages(), python_requires='>=3.6', install_requires=['prettytable>=0.7.2', From 7b3a307cd2a67d17c9fa1c11f0703a5288aa04df Mon Sep 17 00:00:00 2001 From: rajeevgopalakrishna Date: Wed, 16 Oct 2019 14:23:47 +0530 Subject: [PATCH 186/223] Starts adding json formatting of results. --- slither/tools/upgradeability/__main__.py | 23 ++++++++++----- .../upgradeability/check_initialization.py | 19 ++++++++++-- .../upgradeability/compare_function_ids.py | 27 ++++++++++++----- .../upgradeability/compare_variables_order.py | 29 ++++++++++++------- 4 files changed, 70 insertions(+), 28 deletions(-) diff --git a/slither/tools/upgradeability/__main__.py b/slither/tools/upgradeability/__main__.py index e9183a852..f6991923c 100644 --- a/slither/tools/upgradeability/__main__.py +++ b/slither/tools/upgradeability/__main__.py @@ -1,6 +1,7 @@ import logging import argparse import sys +import json from slither import Slither from crytic_compile import cryticparser @@ -9,11 +10,12 @@ from .compare_variables_order import compare_variables_order_implementation, com from .compare_function_ids import compare_function_ids from .check_initialization import check_initialization +from collections import OrderedDict + logging.basicConfig() logging.getLogger("Slither-check-upgradeability").setLevel(logging.INFO) logging.getLogger("Slither").setLevel(logging.INFO) - def parse_args(): parser = argparse.ArgumentParser(description='Slither Upgradeability Checks. For usage information see https://github.com/crytic/slither/wiki/Upgradeability-Checks.', @@ -48,15 +50,20 @@ def main(): v1 = Slither(v1_filename, **vars(args)) v1_name = args.ContractName - check_initialization(v1) + results = OrderedDict() + + results['check_initialization'] = check_initialization(v1) if not args.new_version: - compare_function_ids(v1, v1_name, proxy, proxy_name) - compare_variables_order_proxy(v1, v1_name, proxy, proxy_name) + results['compare_function_ids'] = compare_function_ids(v1, v1_name, proxy, proxy_name) + results['compare_variables_order_proxy'] = compare_variables_order_proxy(v1, v1_name, proxy, proxy_name) else: v2 = Slither(args.new_version, **vars(args)) v2_name = v1_name if not args.new_contract_name else args.new_contract_name - check_initialization(v2) - compare_function_ids(v2, v2_name, proxy, proxy_name) - compare_variables_order_proxy(v2, v2_name, proxy, proxy_name) - compare_variables_order_implementation(v1, v1_name, v2, v2_name) + results['check_initialization_v2'] = check_initialization(v2) + results['compare_function_ids'] = compare_function_ids(v2, v2_name, proxy, proxy_name) + results['compare_variables_order_proxy'] = compare_variables_order_proxy(v2, v2_name, proxy, proxy_name) + results['compare_variables_order_implementation'] = compare_variables_order_implementation(v1, v1_name, v2, v2_name) + + with open('results.json', 'w') as fp: + json.dump(results, fp) diff --git a/slither/tools/upgradeability/check_initialization.py b/slither/tools/upgradeability/check_initialization.py index c81d7a249..03892198c 100644 --- a/slither/tools/upgradeability/check_initialization.py +++ b/slither/tools/upgradeability/check_initialization.py @@ -4,6 +4,8 @@ from slither.slithir.operations import InternalCall from slither.utils.colors import green,red from slither.utils.colors import red, yellow, green +from collections import OrderedDict + logger = logging.getLogger("CheckInitialization") logger.setLevel(logging.INFO) @@ -28,12 +30,15 @@ def _get_most_derived_init(contract): def check_initialization(s): + results = OrderedDict() + initializable = s.get_contract_from_name('Initializable') logger.info(green('Run initialization checks... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#initialization-checks)')) if initializable is None: logger.info(yellow('Initializable contract not found, the contract does not follow a standard initalization schema.')) + results['absent'] = "Initializable contract not found, the contract does not follow a standard initalization schema." return init_info = '' @@ -49,7 +54,9 @@ def check_initialization(s): for f in all_init_functions: if not initializer in f.modifiers: initializer_modifier_missing = True - logger.info(red(f'{f.canonical_name} does not call initializer')) + info = f'{f.canonical_name} does not call initializer' + logger.info(red(info)) + results['missing_initializer_call'] = info most_derived_init = _get_most_derived_init(contract) if most_derived_init is None: init_info += f'{contract.name} has no initialize function\n' @@ -59,11 +66,15 @@ def check_initialization(s): all_init_functions_called = _get_all_internal_calls(most_derived_init) + [most_derived_init] missing_calls = [f for f in all_init_functions if not f in all_init_functions_called] for f in missing_calls: - logger.info(red(f'Missing call to {f.canonical_name} in {contract.name}')) + info = f'Missing call to {f.canonical_name} in {contract.name}' + logger.info(red(info)) + results['missing_call'] = info missing_call = True double_calls = list(set([f for f in all_init_functions_called if all_init_functions_called.count(f) > 1])) for f in double_calls: - logger.info(red(f'{f.canonical_name} is called multiple time in {contract.name}')) + info = f'{f.canonical_name} is called multiple time in {contract.name}' + logger.info(red(info)) + results['multiple_calls'] = info double_calls_found = True if not initializer_modifier_missing: @@ -76,3 +87,5 @@ def check_initialization(s): logger.info(green('No missing call to an init function found')) logger.info(green('Check the deployement script to ensure that these functions are called:\n'+ init_info)) + + return results diff --git a/slither/tools/upgradeability/compare_function_ids.py b/slither/tools/upgradeability/compare_function_ids.py index dd1f85313..f354ff12d 100644 --- a/slither/tools/upgradeability/compare_function_ids.py +++ b/slither/tools/upgradeability/compare_function_ids.py @@ -8,6 +8,8 @@ from slither import Slither from slither.utils.function import get_function_id from slither.utils.colors import red, green +from collections import OrderedDict + logger = logging.getLogger("CompareFunctions") logger.setLevel(logging.INFO) @@ -22,16 +24,22 @@ def get_signatures(c): def compare_function_ids(implem, implem_name, proxy, proxy_name): + results = OrderedDict() + logger.info(green('Run function ids checks... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#functions-ids-checks)')) implem_contract = implem.get_contract_from_name(implem_name) if implem_contract is None: - logger.info(red(f'{implem_name} not found in {implem.filename}')) - return + info = f'{implem_name} not found in {implem.filename}' + logger.info(red(info)) + results['implementation_contract_not_found'] = info + return results proxy_contract = proxy.get_contract_from_name(proxy_name) if proxy_contract is None: - logger.info(red(f'{proxy_name} not found in {proxy.filename}')) - return + info = f'{proxy_name} not found in {proxy.filename}' + logger.info(red(info)) + results['proxy_contract_not_found'] = info + return results signatures_implem = get_signatures(implem_contract) signatures_proxy = get_signatures(proxy_contract) @@ -44,11 +52,16 @@ def compare_function_ids(implem, implem_name, proxy, proxy_name): if k in signatures_ids_proxy: found = True if signatures_ids_implem[k] != signatures_ids_proxy[k]: - logger.info(red('Function id collision found {} {}'.format(signatures_ids_implem[k], - signatures_ids_proxy[k]))) + info = 'Function id collision found {} {}'.format(signatures_ids_implem[k], signatures_ids_proxy[k]) + logger.info(red(info)) + results['function_id_collision'] = info + else: - logger.info(red('Shadowing between proxy and implementation found {}'.format(signatures_ids_implem[k]))) + info = 'Shadowing between proxy and implementation found {}'.format(signatures_ids_implem[k]) + logger.info(red(info)) + results['shadowing'] = info if not found: logger.info(green('No function ids collision found')) + return results diff --git a/slither/tools/upgradeability/compare_variables_order.py b/slither/tools/upgradeability/compare_variables_order.py index 59a3b2f5a..2c98a7af7 100644 --- a/slither/tools/upgradeability/compare_variables_order.py +++ b/slither/tools/upgradeability/compare_variables_order.py @@ -6,11 +6,15 @@ from slither import Slither from slither.utils.function import get_function_id from slither.utils.colors import red, green, yellow +from collections import OrderedDict + logger = logging.getLogger("VariablesOrder") logger.setLevel(logging.INFO) def compare_variables_order_implementation(v1, contract_name1, v2, contract_name2): + results = OrderedDict() + logger.info(green('Run variables order checks between implementations... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#variables-order-checks)')) contract_v1 = v1.get_contract_from_name(contract_name1) @@ -32,16 +36,17 @@ def compare_variables_order_implementation(v1, contract_name1, v2, contract_name for idx in range(0, len(order_v1)): (v1_name, v1_type) = order_v1[idx] if len(order_v2) < idx: - logger.info(red('Missing variable in the new version: {} {}'.format(v1_name, v1_type))) + info = 'Missing variable in the new version: {} {}'.format(v1_name, v1_type) + logger.info(red(info)) + results['missing_variable'] = info continue (v2_name, v2_type) = order_v2[idx] if (v1_name != v2_name) or (v1_type != v2_type): found = True - logger.info(red('Different variables between v1 and v2: {} {} -> {} {}'.format(v1_name, - v1_type, - v2_name, - v2_type))) + info = 'Different variables between v1 and v2: {} {} -> {} {}'.format(v1_name, v1_type, v2_name, v2_type) + logger.info(red(info)) + results['different_variables'] = info if len(order_v2) > len(order_v1): new_variables = order_v2[len(order_v1):] @@ -74,16 +79,20 @@ def compare_variables_order_proxy(implem, implem_name, proxy, proxy_name): for idx in range(0, len(order_proxy)): (proxy_name, proxy_type) = order_proxy[idx] if len(order_implem) <= idx: - logger.info(red('Extra variable in the proxy: {} {}'.format(proxy_name, proxy_type))) + info = 'Extra variable in the proxy: {} {}'.format(proxy_name, proxy_type) + logger.info(red(info)) + results['extra_variable'] = info continue (implem_name, implem_type) = order_implem[idx] if (proxy_name != implem_name) or (proxy_type != implem_type): found = True - logger.info(red('Different variables between proxy and implem: {} {} -> {} {}'.format(proxy_name, - proxy_type, - implem_name, - implem_type))) + info = 'Different variables between proxy and implem: {} {} -> {} {}'.format(proxy_name, + proxy_type, + implem_name, + implem_type) + logger.info(red(info)) + results['different_variable'] = info else: logger.info(yellow('Variable in the proxy: {} {}'.format(proxy_name, proxy_type))) From 10b2da948f20436a6466f53d08155749a017097e Mon Sep 17 00:00:00 2001 From: rajeevgopalakrishna Date: Wed, 16 Oct 2019 16:38:47 +0530 Subject: [PATCH 187/223] Adds json command-line option and code similar to Slither json handling. --- slither/tools/upgradeability/__main__.py | 71 ++++++++++++++++++++---- 1 file changed, 60 insertions(+), 11 deletions(-) diff --git a/slither/tools/upgradeability/__main__.py b/slither/tools/upgradeability/__main__.py index f6991923c..eb56bb0d8 100644 --- a/slither/tools/upgradeability/__main__.py +++ b/slither/tools/upgradeability/__main__.py @@ -2,6 +2,7 @@ import logging import argparse import sys import json +import os from slither import Slither from crytic_compile import cryticparser @@ -31,6 +32,11 @@ def parse_args(): parser.add_argument('--new-version', help='New implementation filename') parser.add_argument('--new-contract-name', help='New contract name (if changed)') + parser.add_argument('--json', + help='Export the results as a JSON file ("--json -" to export to stdout)', + action='store', + default=False) + cryticparser.init(parser) if len(sys.argv) == 1: @@ -39,6 +45,41 @@ def parse_args(): return parser.parse_args() +################################################################################### +################################################################################### +# region Output +################################################################################### +################################################################################### + + +def output_json(filename, error, results): + # Create our encapsulated JSON result. + json_result = { + "success": error is None, + "error": error, + "results": results + } + + # Determine if we should output to stdout + if filename is None: + # Write json to console + print(json.dumps(json_result)) + else: + # Write json to file + if os.path.isfile(filename): + logger.info(yellow(f'{filename} exists already, the overwrite is prevented')) + else: + with open(filename, 'w', encoding='utf8') as f: + json.dump(json_result, f, indent=2) + +# endregion +################################################################################### +################################################################################### +# region Main +################################################################################### +################################################################################### + + def main(): args = parse_args() @@ -50,20 +91,28 @@ def main(): v1 = Slither(v1_filename, **vars(args)) v1_name = args.ContractName - results = OrderedDict() - - results['check_initialization'] = check_initialization(v1) + # Define some variables for potential JSON output + json_results = {} + output_error = None + outputting_json = args.json is not None + outputting_json_stdout = args.json == '-' + + json_results['check-initialization'] = check_initialization(v1) if not args.new_version: - results['compare_function_ids'] = compare_function_ids(v1, v1_name, proxy, proxy_name) - results['compare_variables_order_proxy'] = compare_variables_order_proxy(v1, v1_name, proxy, proxy_name) + json_results['compare-function-ids'] = compare_function_ids(v1, v1_name, proxy, proxy_name) + json_results['compare-variables-order-proxy'] = compare_variables_order_proxy(v1, v1_name, proxy, proxy_name) else: v2 = Slither(args.new_version, **vars(args)) v2_name = v1_name if not args.new_contract_name else args.new_contract_name - results['check_initialization_v2'] = check_initialization(v2) - results['compare_function_ids'] = compare_function_ids(v2, v2_name, proxy, proxy_name) - results['compare_variables_order_proxy'] = compare_variables_order_proxy(v2, v2_name, proxy, proxy_name) - results['compare_variables_order_implementation'] = compare_variables_order_implementation(v1, v1_name, v2, v2_name) + json_results['check-initialization-v2'] = check_initialization(v2) + json_results['compare-function-ids'] = compare_function_ids(v2, v2_name, proxy, proxy_name) + json_results['compare-variables-order-proxy'] = compare_variables_order_proxy(v2, v2_name, proxy, proxy_name) + json_results['compare-variables-order-implementation'] = compare_variables_order_implementation(v1, v1_name, v2, v2_name) + + # If we are outputting JSON, capture the redirected output and disable the redirect to output the final JSON. + if outputting_json: + output_json(None if outputting_json_stdout else args.json, output_error, json_results) - with open('results.json', 'w') as fp: - json.dump(results, fp) + +# endregion From 0907fb5006240a0dc8ed52c702ec45f89e10ccd6 Mon Sep 17 00:00:00 2001 From: rajeevgopalakrishna Date: Thu, 17 Oct 2019 09:33:23 +0530 Subject: [PATCH 188/223] Completes first iteration of adding json txt log support. Passes the five tests in Travis. Todo: Add source mapping and other useful info. --- slither/tools/upgradeability/__main__.py | 22 ++++++--- .../upgradeability/check_initialization.py | 14 +++--- .../upgradeability/compare_function_ids.py | 10 ++-- .../upgradeability/compare_variables_order.py | 49 ++++++++++++------- 4 files changed, 56 insertions(+), 39 deletions(-) diff --git a/slither/tools/upgradeability/__main__.py b/slither/tools/upgradeability/__main__.py index eb56bb0d8..f02609c1b 100644 --- a/slither/tools/upgradeability/__main__.py +++ b/slither/tools/upgradeability/__main__.py @@ -5,6 +5,7 @@ import json import os from slither import Slither +from slither.utils.colors import red, yellow, set_colorization_enabled from crytic_compile import cryticparser from .compare_variables_order import compare_variables_order_implementation, compare_variables_order_proxy @@ -14,8 +15,8 @@ from .check_initialization import check_initialization from collections import OrderedDict logging.basicConfig() -logging.getLogger("Slither-check-upgradeability").setLevel(logging.INFO) -logging.getLogger("Slither").setLevel(logging.INFO) +logger = logging.getLogger("Slither-check-upgradeability") +logger.setLevel(logging.INFO) def parse_args(): @@ -55,7 +56,7 @@ def parse_args(): def output_json(filename, error, results): # Create our encapsulated JSON result. json_result = { - "success": error is None, + "success": error == None, "error": error, "results": results } @@ -93,7 +94,7 @@ def main(): # Define some variables for potential JSON output json_results = {} - output_error = None + output_error = '' outputting_json = args.json is not None outputting_json_stdout = args.json == '-' @@ -107,9 +108,16 @@ def main(): v2_name = v1_name if not args.new_contract_name else args.new_contract_name json_results['check-initialization-v2'] = check_initialization(v2) json_results['compare-function-ids'] = compare_function_ids(v2, v2_name, proxy, proxy_name) - json_results['compare-variables-order-proxy'] = compare_variables_order_proxy(v2, v2_name, proxy, proxy_name) - json_results['compare-variables-order-implementation'] = compare_variables_order_implementation(v1, v1_name, v2, v2_name) - + results = compare_variables_order_proxy(v2, v2_name, proxy, proxy_name) + output_error = results.get('output-error', '') + json_results['compare-variables-order-proxy'] = results + results = compare_variables_order_implementation(v1, v1_name, v2, v2_name) + output_error += results.get('output-error', '') + json_results['compare-variables-order-implementation'] = results + + if output_error == '': + output_error = None + # If we are outputting JSON, capture the redirected output and disable the redirect to output the final JSON. if outputting_json: output_json(None if outputting_json_stdout else args.json, output_error, json_results) diff --git a/slither/tools/upgradeability/check_initialization.py b/slither/tools/upgradeability/check_initialization.py index 03892198c..442b68aa2 100644 --- a/slither/tools/upgradeability/check_initialization.py +++ b/slither/tools/upgradeability/check_initialization.py @@ -4,8 +4,6 @@ from slither.slithir.operations import InternalCall from slither.utils.colors import green,red from slither.utils.colors import red, yellow, green -from collections import OrderedDict - logger = logging.getLogger("CheckInitialization") logger.setLevel(logging.INFO) @@ -30,7 +28,7 @@ def _get_most_derived_init(contract): def check_initialization(s): - results = OrderedDict() + results = {} initializable = s.get_contract_from_name('Initializable') @@ -39,7 +37,7 @@ def check_initialization(s): if initializable is None: logger.info(yellow('Initializable contract not found, the contract does not follow a standard initalization schema.')) results['absent'] = "Initializable contract not found, the contract does not follow a standard initalization schema." - return + return results init_info = '' @@ -56,7 +54,7 @@ def check_initialization(s): initializer_modifier_missing = True info = f'{f.canonical_name} does not call initializer' logger.info(red(info)) - results['missing_initializer_call'] = info + results['missing-initializer-call'] = info most_derived_init = _get_most_derived_init(contract) if most_derived_init is None: init_info += f'{contract.name} has no initialize function\n' @@ -68,13 +66,13 @@ def check_initialization(s): for f in missing_calls: info = f'Missing call to {f.canonical_name} in {contract.name}' logger.info(red(info)) - results['missing_call'] = info + results['missing-call'] = info missing_call = True double_calls = list(set([f for f in all_init_functions_called if all_init_functions_called.count(f) > 1])) for f in double_calls: - info = f'{f.canonical_name} is called multiple time in {contract.name}' + info = f'{f.canonical_name} is called multiple times in {contract.name}' logger.info(red(info)) - results['multiple_calls'] = info + results['multiple-calls'] = info double_calls_found = True if not initializer_modifier_missing: diff --git a/slither/tools/upgradeability/compare_function_ids.py b/slither/tools/upgradeability/compare_function_ids.py index f354ff12d..0869b290c 100644 --- a/slither/tools/upgradeability/compare_function_ids.py +++ b/slither/tools/upgradeability/compare_function_ids.py @@ -8,8 +8,6 @@ from slither import Slither from slither.utils.function import get_function_id from slither.utils.colors import red, green -from collections import OrderedDict - logger = logging.getLogger("CompareFunctions") logger.setLevel(logging.INFO) @@ -24,7 +22,7 @@ def get_signatures(c): def compare_function_ids(implem, implem_name, proxy, proxy_name): - results = OrderedDict() + results = {} logger.info(green('Run function ids checks... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#functions-ids-checks)')) @@ -32,13 +30,13 @@ def compare_function_ids(implem, implem_name, proxy, proxy_name): if implem_contract is None: info = f'{implem_name} not found in {implem.filename}' logger.info(red(info)) - results['implementation_contract_not_found'] = info + results['implementation-contract-not-found'] = info return results proxy_contract = proxy.get_contract_from_name(proxy_name) if proxy_contract is None: info = f'{proxy_name} not found in {proxy.filename}' logger.info(red(info)) - results['proxy_contract_not_found'] = info + results['proxy-contract-not-found'] = info return results signatures_implem = get_signatures(implem_contract) @@ -54,7 +52,7 @@ def compare_function_ids(implem, implem_name, proxy, proxy_name): if signatures_ids_implem[k] != signatures_ids_proxy[k]: info = 'Function id collision found {} {}'.format(signatures_ids_implem[k], signatures_ids_proxy[k]) logger.info(red(info)) - results['function_id_collision'] = info + results['function-id-collision'] = info else: info = 'Shadowing between proxy and implementation found {}'.format(signatures_ids_implem[k]) diff --git a/slither/tools/upgradeability/compare_variables_order.py b/slither/tools/upgradeability/compare_variables_order.py index 2c98a7af7..2a9bd64ef 100644 --- a/slither/tools/upgradeability/compare_variables_order.py +++ b/slither/tools/upgradeability/compare_variables_order.py @@ -6,39 +6,41 @@ from slither import Slither from slither.utils.function import get_function_id from slither.utils.colors import red, green, yellow -from collections import OrderedDict - logger = logging.getLogger("VariablesOrder") logger.setLevel(logging.INFO) def compare_variables_order_implementation(v1, contract_name1, v2, contract_name2): - results = OrderedDict() + results = {} logger.info(green('Run variables order checks between implementations... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#variables-order-checks)')) contract_v1 = v1.get_contract_from_name(contract_name1) if contract_v1 is None: - logger.info(red('Contract {} not found in {}'.format(contract_name1, v1.filename))) - exit(-1) + info = 'Contract {} not found in {}'.format(contract_name1, v1.filename) + logger.info(red(info)) + results['output-error'] = info + return results contract_v2 = v2.get_contract_from_name(contract_name2) if contract_v2 is None: - logger.info(red('Contract {} not found in {}'.format(contract_name2, v2.filename))) - exit(-1) - + info = 'Contract {} not found in {}'.format(contract_name2, v2.filename) + logger.info(red(info)) + results['output-error'] = info + return results order_v1 = [(variable.name, variable.type) for variable in contract_v1.state_variables if not variable.is_constant] order_v2 = [(variable.name, variable.type) for variable in contract_v2.state_variables if not variable.is_constant] - + results['missing-variable'] = [] + results['different-variables'] = [] found = False for idx in range(0, len(order_v1)): (v1_name, v1_type) = order_v1[idx] if len(order_v2) < idx: info = 'Missing variable in the new version: {} {}'.format(v1_name, v1_type) logger.info(red(info)) - results['missing_variable'] = info + results['missing-variable'].append(info) continue (v2_name, v2_type) = order_v2[idx] @@ -46,7 +48,7 @@ def compare_variables_order_implementation(v1, contract_name1, v2, contract_name found = True info = 'Different variables between v1 and v2: {} {} -> {} {}'.format(v1_name, v1_type, v2_name, v2_type) logger.info(red(info)) - results['different_variables'] = info + results['different-variables'].append(info) if len(order_v2) > len(order_v1): new_variables = order_v2[len(order_v1):] @@ -56,32 +58,42 @@ def compare_variables_order_implementation(v1, contract_name1, v2, contract_name if not found: logger.info(green('No variables ordering error found between implementations')) + return results + + def compare_variables_order_proxy(implem, implem_name, proxy, proxy_name): + results = {} + logger.info(green('Run variables order checks between the implementation and the proxy... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#variables-order-checks)')) contract_implem = implem.get_contract_from_name(implem_name) if contract_implem is None: - logger.info(red('Contract {} not found in {}'.format(implem_name, implem.filename))) - exit(-1) + info = 'Contract {} not found in {}'.format(implem_name, implem.filename) + logger.info(red(info)) + results['output-error'] = info + return results contract_proxy = proxy.get_contract_from_name(proxy_name) if contract_proxy is None: - logger.info(red('Contract {} not found in {}'.format(proxy_name, proxy.filename))) - exit(-1) - + info = 'Contract {} not found in {}'.format(proxy_name, proxy.filename) + logger.info(red(info)) + results['output-error'] = info + return results order_implem = [(variable.name, variable.type) for variable in contract_implem.state_variables if not variable.is_constant] order_proxy = [(variable.name, variable.type) for variable in contract_proxy.state_variables if not variable.is_constant] + results['extra-variable'] = [] + results['different-variables'] = [] found = False for idx in range(0, len(order_proxy)): (proxy_name, proxy_type) = order_proxy[idx] if len(order_implem) <= idx: info = 'Extra variable in the proxy: {} {}'.format(proxy_name, proxy_type) logger.info(red(info)) - results['extra_variable'] = info + results['extra-variable'].append(info) continue (implem_name, implem_type) = order_implem[idx] @@ -92,7 +104,7 @@ def compare_variables_order_proxy(implem, implem_name, proxy, proxy_name): implem_name, implem_type) logger.info(red(info)) - results['different_variable'] = info + results['different-variables'].append(info) else: logger.info(yellow('Variable in the proxy: {} {}'.format(proxy_name, proxy_type))) @@ -107,3 +119,4 @@ def compare_variables_order_proxy(implem, implem_name, proxy, proxy_name): logger.info(green('No variables ordering error found between implementation and the proxy')) + return results From 1af9e0271671fff6c8ed9a70310b498d09e9c970 Mon Sep 17 00:00:00 2001 From: rajeevgopalakrishna Date: Thu, 17 Oct 2019 19:03:07 +0530 Subject: [PATCH 189/223] Adds SlitherException instead of tracking error in dict. --- slither/tools/upgradeability/__main__.py | 20 +++++++++++++++---- .../upgradeability/compare_variables_order.py | 7 +++---- 2 files changed, 19 insertions(+), 8 deletions(-) diff --git a/slither/tools/upgradeability/__main__.py b/slither/tools/upgradeability/__main__.py index f02609c1b..aa0517b4a 100644 --- a/slither/tools/upgradeability/__main__.py +++ b/slither/tools/upgradeability/__main__.py @@ -7,6 +7,7 @@ import os from slither import Slither from slither.utils.colors import red, yellow, set_colorization_enabled from crytic_compile import cryticparser +from slither.exceptions import SlitherException from .compare_variables_order import compare_variables_order_implementation, compare_variables_order_proxy from .compare_function_ids import compare_function_ids @@ -106,13 +107,24 @@ def main(): else: v2 = Slither(args.new_version, **vars(args)) v2_name = v1_name if not args.new_contract_name else args.new_contract_name + json_results['check-initialization-v2'] = check_initialization(v2) + json_results['compare-function-ids'] = compare_function_ids(v2, v2_name, proxy, proxy_name) - results = compare_variables_order_proxy(v2, v2_name, proxy, proxy_name) - output_error = results.get('output-error', '') + + results = {} + output_error = '' + + try: + results = compare_variables_order_proxy(v2, v2_name, proxy, proxy_name) + except SlitherException as se: + output_error = str(se) json_results['compare-variables-order-proxy'] = results - results = compare_variables_order_implementation(v1, v1_name, v2, v2_name) - output_error += results.get('output-error', '') + + try: + results = compare_variables_order_implementation(v1, v1_name, v2, v2_name) + except SlitherException as se: + output_error += str(se) json_results['compare-variables-order-implementation'] = results if output_error == '': diff --git a/slither/tools/upgradeability/compare_variables_order.py b/slither/tools/upgradeability/compare_variables_order.py index 2a9bd64ef..27e16aa31 100644 --- a/slither/tools/upgradeability/compare_variables_order.py +++ b/slither/tools/upgradeability/compare_variables_order.py @@ -5,6 +5,7 @@ import logging from slither import Slither from slither.utils.function import get_function_id from slither.utils.colors import red, green, yellow +from slither.exceptions import SlitherException logger = logging.getLogger("VariablesOrder") logger.setLevel(logging.INFO) @@ -71,15 +72,13 @@ def compare_variables_order_proxy(implem, implem_name, proxy, proxy_name): if contract_implem is None: info = 'Contract {} not found in {}'.format(implem_name, implem.filename) logger.info(red(info)) - results['output-error'] = info - return results + raise SlitherException(info) contract_proxy = proxy.get_contract_from_name(proxy_name) if contract_proxy is None: info = 'Contract {} not found in {}'.format(proxy_name, proxy.filename) logger.info(red(info)) - results['output-error'] = info - return results + raise SlitherException(info) order_implem = [(variable.name, variable.type) for variable in contract_implem.state_variables if not variable.is_constant] order_proxy = [(variable.name, variable.type) for variable in contract_proxy.state_variables if not variable.is_constant] From e98a6dd8c7a8a4084847c9e87da19d382d1bad69 Mon Sep 17 00:00:00 2001 From: rajeevgopalakrishna Date: Fri, 18 Oct 2019 11:49:38 +0530 Subject: [PATCH 190/223] Adds SlitherException instead of tracking error in dict. --- slither/tools/upgradeability/compare_variables_order.py | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/slither/tools/upgradeability/compare_variables_order.py b/slither/tools/upgradeability/compare_variables_order.py index 27e16aa31..b02d6466d 100644 --- a/slither/tools/upgradeability/compare_variables_order.py +++ b/slither/tools/upgradeability/compare_variables_order.py @@ -20,15 +20,13 @@ def compare_variables_order_implementation(v1, contract_name1, v2, contract_name if contract_v1 is None: info = 'Contract {} not found in {}'.format(contract_name1, v1.filename) logger.info(red(info)) - results['output-error'] = info - return results + raise SlitherException(info) contract_v2 = v2.get_contract_from_name(contract_name2) if contract_v2 is None: info = 'Contract {} not found in {}'.format(contract_name2, v2.filename) logger.info(red(info)) - results['output-error'] = info - return results + raise SlitherException(info) order_v1 = [(variable.name, variable.type) for variable in contract_v1.state_variables if not variable.is_constant] order_v2 = [(variable.name, variable.type) for variable in contract_v2.state_variables if not variable.is_constant] From eb580f1ad92763710ec95f694eab2a4ffd4b94a8 Mon Sep 17 00:00:00 2001 From: rajeevgopalakrishna Date: Sat, 19 Oct 2019 13:54:05 +0530 Subject: [PATCH 191/223] Adds upgradeability-check key to the results JSON format. --- slither/tools/upgradeability/__main__.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/slither/tools/upgradeability/__main__.py b/slither/tools/upgradeability/__main__.py index aa0517b4a..74e71ab73 100644 --- a/slither/tools/upgradeability/__main__.py +++ b/slither/tools/upgradeability/__main__.py @@ -59,7 +59,9 @@ def output_json(filename, error, results): json_result = { "success": error == None, "error": error, - "results": results + "results": { + "upgradeability-check": results + } } # Determine if we should output to stdout From ee3738cd510921585e98a39593cd46ab8b78fff5 Mon Sep 17 00:00:00 2001 From: Josselin Date: Sat, 19 Oct 2019 11:29:12 +0200 Subject: [PATCH 192/223] Add slither-erc util. Check for most common ERC conformance --- setup.py | 3 +- slither/core/declarations/contract.py | 18 +- slither/tools/erc_conformance/README.md | 1 + slither/tools/erc_conformance/__init__.py | 0 slither/tools/erc_conformance/__main__.py | 71 +++++++ slither/tools/erc_conformance/erc/erc165.py | 25 +++ slither/tools/erc_conformance/erc/erc1820.py | 25 +++ slither/tools/erc_conformance/erc/erc20.py | 26 +++ slither/tools/erc_conformance/erc/erc223.py | 25 +++ slither/tools/erc_conformance/erc/erc721.py | 25 +++ slither/tools/erc_conformance/erc/erc777.py | 25 +++ slither/tools/erc_conformance/erc/ercs.py | 198 +++++++++++++++++++ slither/utils/erc.py | 149 ++++++++++---- slither/utils/type.py | 15 ++ 14 files changed, 559 insertions(+), 47 deletions(-) create mode 100644 slither/tools/erc_conformance/README.md create mode 100644 slither/tools/erc_conformance/__init__.py create mode 100644 slither/tools/erc_conformance/__main__.py create mode 100644 slither/tools/erc_conformance/erc/erc165.py create mode 100644 slither/tools/erc_conformance/erc/erc1820.py create mode 100644 slither/tools/erc_conformance/erc/erc20.py create mode 100644 slither/tools/erc_conformance/erc/erc223.py create mode 100644 slither/tools/erc_conformance/erc/erc721.py create mode 100644 slither/tools/erc_conformance/erc/erc777.py create mode 100644 slither/tools/erc_conformance/erc/ercs.py diff --git a/setup.py b/setup.py index 2fd078d92..1ea940498 100644 --- a/setup.py +++ b/setup.py @@ -21,7 +21,8 @@ setup( 'slither-find-paths = slither.tools.possible_paths.__main__:main', 'slither-simil = slither.tools.similarity.__main__:main', 'slither-flat = slither.tools.flattening.__main__:main', - 'slither-format = slither.tools.slither_format.__main__:main' + 'slither-format = slither.tools.slither_format.__main__:main', + 'slither-erc = slither.tools.erc_conformance.__main__:main' ] } ) diff --git a/slither/core/declarations/contract.py b/slither/core/declarations/contract.py index 23317c6ce..f30a5b5d9 100644 --- a/slither/core/declarations/contract.py +++ b/slither/core/declarations/contract.py @@ -528,15 +528,25 @@ class Contract(ChildSlither, SourceMapping): """ return next((st for st in self.structures if st.canonical_name == structure_name), None) - def get_event_from_name(self, event_name): + def get_event_from_signature(self, event_signature): """ - Return an event from a name + Return an event from a signature Args: - event_name (str): name of the event + event_signature (str): signature of the event Returns: Event """ - return next((e for e in self.events if e.name == event_name), None) + return next((e for e in self.events if e.full_name == event_signature), None) + + def get_event_from_canonical_name(self, event_canonical_name): + """ + Return an event from a canonical name + Args: + event_canonical_name (str): name of the event + Returns: + Event + """ + return next((e for e in self.events if e.canonical_name == event_canonical_name), None) def get_enum_from_name(self, enum_name): """ diff --git a/slither/tools/erc_conformance/README.md b/slither/tools/erc_conformance/README.md new file mode 100644 index 000000000..a04677a65 --- /dev/null +++ b/slither/tools/erc_conformance/README.md @@ -0,0 +1 @@ +## ERC conformance \ No newline at end of file diff --git a/slither/tools/erc_conformance/__init__.py b/slither/tools/erc_conformance/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/slither/tools/erc_conformance/__main__.py b/slither/tools/erc_conformance/__main__.py new file mode 100644 index 000000000..59043fa06 --- /dev/null +++ b/slither/tools/erc_conformance/__main__.py @@ -0,0 +1,71 @@ +import argparse +import logging +from slither import Slither +from crytic_compile import cryticparser +from slither.utils.erc import ERCS +from .erc.ercs import generic_erc_checks + +logging.basicConfig() +logging.getLogger("Slither").setLevel(logging.INFO) + +logger = logging.getLogger("Slither-conformance") +logger.setLevel(logging.INFO) + +ch = logging.StreamHandler() +ch.setLevel(logging.INFO) +formatter = logging.Formatter('%(message)s') +logger.addHandler(ch) +logger.handlers[0].setFormatter(formatter) +logger.propagate = False + + + +def parse_args(): + """ + Parse the underlying arguments for the program. + :return: Returns the arguments for the program. + """ + parser = argparse.ArgumentParser(description='Check the ERC 20 conformance', + usage='slither-erc project contractName') + + parser.add_argument('project', + help='The codebase to be tested.') + + parser.add_argument('contract_name', + help='The name of the contract. Specify the first case contract that follow the standard. Derived contracts will be checked.') + + parser.add_argument( + "--erc", + help=f"ERC to be tested, available {','.join(ERCS.keys())} (default ERC20)", + action="store", + default="erc20", + ) + + # Add default arguments from crytic-compile + cryticparser.init(parser) + + return parser.parse_args() + +def main(): + args = parse_args() + + # Perform slither analysis on the given filename + slither = Slither(args.project, **vars(args)) + + if args.erc.upper() in ERCS: + + contract = slither.get_contract_from_name(args.contract_name) + + if not contract: + logger.error(f'Contract not found: {args.contract_name}') + return + # First elem is the function, second is the event + erc = ERCS[args.erc.upper()] + generic_erc_checks(contract, erc[0], erc[1]) + else: + logger.error(f'Incorrect ERC selected {args.erc}') + return + + +if __name__ == '__main__': + main() diff --git a/slither/tools/erc_conformance/erc/erc165.py b/slither/tools/erc_conformance/erc/erc165.py new file mode 100644 index 000000000..4d0e72860 --- /dev/null +++ b/slither/tools/erc_conformance/erc/erc165.py @@ -0,0 +1,25 @@ +import logging +from collections import defaultdict +from slither.utils.erc import ERC165 +from .ercs import generic_erc_checks +from slither.exceptions import SlitherException + +logger = logging.getLogger("Slither-conformance") + +def check_erc165(slither, contract_name): + + contract = slither.get_contract_from_name(contract_name) + + if not contract: + raise SlitherException(f'{contract_name} not found') + + signatures = generic_erc_checks(contract, ERC165) + + ret = defaultdict(dict) + + ret['erc165'] = { + "signatures": signatures + } + + return ret + diff --git a/slither/tools/erc_conformance/erc/erc1820.py b/slither/tools/erc_conformance/erc/erc1820.py new file mode 100644 index 000000000..e47db9e63 --- /dev/null +++ b/slither/tools/erc_conformance/erc/erc1820.py @@ -0,0 +1,25 @@ +import logging +from collections import defaultdict +from slither.utils.erc import ERC1820 +from .ercs import generic_erc_checks +from slither.exceptions import SlitherException + +logger = logging.getLogger("Slither-conformance") + +def check_erc1820(slither, contract_name): + + contract = slither.get_contract_from_name(contract_name) + + if not contract: + raise SlitherException(f'{contract_name} not found') + + signatures = generic_erc_checks(contract, ERC1820) + + ret = defaultdict(dict) + + ret['erc1820'] = { + "signatures": signatures + } + + return ret + diff --git a/slither/tools/erc_conformance/erc/erc20.py b/slither/tools/erc_conformance/erc/erc20.py new file mode 100644 index 000000000..b02d81b72 --- /dev/null +++ b/slither/tools/erc_conformance/erc/erc20.py @@ -0,0 +1,26 @@ +import logging +from collections import defaultdict +from slither.utils.erc import ERC20, ERC20_EVENTS +from .ercs import generic_erc_checks +from slither.exceptions import SlitherException + +logger = logging.getLogger("Slither-conformance") + +def check_erc20(slither, contract_name): + + contract = slither.get_contract_from_name(contract_name) + + if not contract: + raise SlitherException(f'{contract_name} not found') + + signatures = generic_erc_checks(contract, ERC20, ERC20_EVENTS) + + ret = defaultdict(dict) + + ret['erc20'] = { + "signatures": signatures + } + + return ret + + diff --git a/slither/tools/erc_conformance/erc/erc223.py b/slither/tools/erc_conformance/erc/erc223.py new file mode 100644 index 000000000..889c5ea5a --- /dev/null +++ b/slither/tools/erc_conformance/erc/erc223.py @@ -0,0 +1,25 @@ +import logging +from collections import defaultdict +from slither.utils.erc import ERC223 +from .ercs import generic_erc_checks +from slither.exceptions import SlitherException + +logger = logging.getLogger("Slither-conformance") + +def check_erc223(slither, contract_name): + + contract = slither.get_contract_from_name(contract_name) + + if not contract: + raise SlitherException(f'{contract_name} not found') + + signatures = generic_erc_checks(contract, ERC223) + + ret = defaultdict(dict) + + ret['erc223'] = { + "signatures": signatures + } + + return ret + diff --git a/slither/tools/erc_conformance/erc/erc721.py b/slither/tools/erc_conformance/erc/erc721.py new file mode 100644 index 000000000..77094e747 --- /dev/null +++ b/slither/tools/erc_conformance/erc/erc721.py @@ -0,0 +1,25 @@ +import logging +from collections import defaultdict +from slither.utils.erc import ERC721 +from .ercs import generic_erc_checks +from slither.exceptions import SlitherException + +logger = logging.getLogger("Slither-conformance") + +def check_erc721(slither, contract_name): + + contract = slither.get_contract_from_name(contract_name) + + if not contract: + raise SlitherException(f'{contract_name} not found') + + signatures = generic_erc_checks(contract, ERC721) + + ret = defaultdict(dict) + + ret['erc721'] = { + "signatures": signatures + } + + return ret + diff --git a/slither/tools/erc_conformance/erc/erc777.py b/slither/tools/erc_conformance/erc/erc777.py new file mode 100644 index 000000000..ad6ad93cc --- /dev/null +++ b/slither/tools/erc_conformance/erc/erc777.py @@ -0,0 +1,25 @@ +import logging +from collections import defaultdict +from slither.utils.erc import ERC777 +from .ercs import generic_erc_checks +from slither.exceptions import SlitherException + +logger = logging.getLogger("Slither-conformance") + +def check_erc777(slither, contract_name): + + contract = slither.get_contract_from_name(contract_name) + + if not contract: + raise SlitherException(f'{contract_name} not found') + + signatures = generic_erc_checks(contract, ERC777) + + ret = defaultdict(dict) + + ret['erc777'] = { + "signatures": signatures + } + + return ret + diff --git a/slither/tools/erc_conformance/erc/ercs.py b/slither/tools/erc_conformance/erc/ercs.py new file mode 100644 index 000000000..8e23caf8e --- /dev/null +++ b/slither/tools/erc_conformance/erc/ercs.py @@ -0,0 +1,198 @@ +import logging +from collections import defaultdict + +from slither.core.solidity_types import MappingType +from slither.slithir.operations import EventCall +from slither.utils.type import export_nested_types_from_variable, export_return_type_from_variable + +logger = logging.getLogger("Slither-conformance") + + +def _check_signature(erc_function, contract, ret): + name = erc_function.name + parameters = erc_function.parameters + return_type = erc_function.return_type + view = erc_function.view + required = erc_function.required + events = erc_function.events + + sig = f'{name}({",".join(parameters)})' + function = contract.get_function_from_signature(sig) + + if not function: + # The check on state variable is needed until we have a better API to handle state variable getters + state_variable_as_function = contract.get_state_variable_from_name(name) + + if not state_variable_as_function or not state_variable_as_function.visibility in ['public', 'external']: + txt = f'[ ] {sig} is missing {"" if required else "(optional)"}' + logger.info(txt) + ret["missing_function"].append({ + "description": txt, + "contract": contract.name, + "function": sig, + "required": required + }) + return + + types = [str(x) for x in export_nested_types_from_variable(state_variable_as_function)] + + if types != parameters: + txt = f'[ ] {sig} is missing {"" if required else "(optional)"}' + logger.info(txt) + ret["missing_function"].append({ + "description": txt, + "contract": contract.name, + "function": sig, + "required": required + }) + return + + function_return_type = [export_return_type_from_variable(state_variable_as_function)] + + function_view = True + else: + function_return_type = function.return_type + function_view = function.view + + txt = f'[✓] {sig} is present' + logger.info(txt) + + if function_return_type: + function_return_type = ','.join([str(x) for x in function_return_type]) + if function_return_type == return_type: + txt = f'\t[✓] {sig} -> () (correct return value)' + logger.info(txt) + else: + txt = f'\t[ ] {sig} -> () should return {return_type}' + ret["incorrect_return_type"].append({ + "description": txt, + "contract": contract.name, + "function": sig, + "expected_return_type": return_type, + "actual_return_type": function_return_type + }) + logger.info(txt) + elif not return_type: + txt = f'\t[✓] {sig} -> () (correct return type)' + logger.info(txt) + else: + txt = f'\t[ ] {sig} -> () should return {return_type}' + ret["incorrect_return_type"].append({ + "description": txt, + "contract": contract.name, + "function": sig, + "expected_return_type": return_type, + "actual_return_type": "" + }) + logger.info(txt) + + if view: + if function_view: + txt = f'\t[✓] {sig} is view' + logger.info(txt) + else: + txt = f'\t[ ] {sig} should be view' + ret["should_be_view"].append({ + "description": txt, + "contract": contract.name, + "function": sig + }) + logger.info(txt) + + if events: + for event in events: + event_sig = f'{event.name}({",".join(event.parameters)})' + + if not function: + txt = f'\t[ ] Must emit be view {event_sig}' + ret["missing_event_emmited"].append({ + "description": txt, + "contract": contract.name, + "function": sig, + "missing_event": event_sig + }) + logger.info(txt) + else: + event_found = False + for ir in function.all_slithir_operations(): + if isinstance(ir, EventCall): + if ir.name == event.name: + if event.parameters == [str(a.type) for a in ir.arguments]: + event_found = True + break + if event_found: + txt = f'\t[✓] {event_sig} is emitted' + logger.info(txt) + else: + txt = f'\t[ ] Must emit be view {event_sig}' + ret["missing_event_emmited"].append({ + "description": txt, + "contract": contract.name, + "function": sig, + "missing_event": event_sig + }) + logger.info(txt) + + + + +def _check_events(erc_event, contract, ret): + name = erc_event.name + parameters = erc_event.parameters + indexes = erc_event.indexes + + sig = f'{name}({",".join(parameters)})' + event = contract.get_event_from_signature(sig) + + if not event: + txt = f'[ ] {sig} is missing' + logger.info(txt) + ret["missing_event"].append({ + "description": txt, + "contract": contract.name, + "event": sig + }) + return + + txt = f'[✓] {sig} is present' + logger.info(txt) + + for i, index in enumerate(indexes): + if index: + if event.elems[i].indexed: + txt = f'\t[✓] parameter {i} is indexed' + logger.info(txt) + else: + txt = f'\t[ ] parameter {i} should be indexed' + logger.info(txt) + ret["missing_event_index"].append({ + "description": txt, + "contract": contract.name, + "event": sig, + "missing_index": i + }) + + + +def generic_erc_checks(contract, erc_functions, erc_events, explored=None): + + if explored is None: + explored = set() + + explored.add(contract) + + ret = defaultdict(list) + + logger.info(f'# Check {contract.name}\n') + + logger.info(f'## Check functions') + for erc_function in erc_functions: + _check_signature(erc_function, contract, ret) + logger.info(f'\n## Check events') + for erc_event in erc_events: + _check_events(erc_event, contract, ret) + + logger.info('\n') + + for derived_contract in contract.derived_contracts: + generic_erc_checks(derived_contract, erc_functions, erc_events, explored) \ No newline at end of file diff --git a/slither/utils/erc.py b/slither/utils/erc.py index 21c2c53a5..7b40e5b40 100644 --- a/slither/utils/erc.py +++ b/slither/utils/erc.py @@ -1,69 +1,134 @@ +from collections import namedtuple def erc_to_signatures(erc): - return [f'{e[0]}({",".join(e[1])})' for e in erc] + ''' + Return the list of mandatory signatures + :param erc: + :return: + ''' + return [f'{e.name}({",".join(e.parameters)})' for e in erc if e.required] +ERC = namedtuple('ERC', ['name', 'parameters', 'return_type', 'view', 'required', 'events']) + +ERC_EVENT = namedtuple('ERC_EVENT', ['name', 'parameters', "indexes"]) + # Final # https://eips.ethereum.org/EIPS/eip-20 -# name, symbolc, decimals are optionals -ERC20 = [('totalSupply', [], 'uint256'), - ('balanceOf', ['address'], 'uint256'), - ('transfer', ['address', 'uint256'], 'bool'), - ('transferFrom', ['address', 'address', 'uint256'], 'bool'), - ('approve', ['address', 'uint256'], 'bool'), - ('allowance', ['address', 'address'], 'uint256')] + +ERC20_transfer_event = ERC_EVENT("Transfer", ["address", "address", "uint256"], [True, True, False]) +ERC20_approval_event = ERC_EVENT("Approval", ["address", "address", "uint256"], [True, True, False]) +ERC20_EVENTS = [ERC20_transfer_event, ERC20_approval_event] + +ERC20 = [ERC('totalSupply', [], 'uint256', True, True, []), + ERC('balanceOf', ['address'], 'uint256', True, True, []), + ERC('transfer', ['address', 'uint256'], 'bool', False, True, [ERC20_transfer_event]), + ERC('transferFrom', ['address', 'address', 'uint256'], 'bool', False, True, [ERC20_transfer_event]), + ERC('approve', ['address', 'uint256'], 'bool', False, True, [ERC20_approval_event]), + ERC('allowance', ['address', 'address'], 'uint256', True, True, [])] + +ERC20_OPTIONAL = [ERC('name', [], 'string', True, False, []), + ERC('symbol', [], 'string', True, False, []), + ERC('decimals', [], 'string', True, False, [])] + +ERC20 = ERC20 + ERC20_OPTIONAL + ERC20_signatures = erc_to_signatures(ERC20) # Draft # https://github.com/ethereum/eips/issues/223 -ERC223 = [('name', [], 'string'), - ('symbol', [], 'string'), - ('decimals', [], 'uint8'), - ('totalSupply', [], 'uint256'), - ('balanceOf', ['address'], 'uint256'), - ('transfer', ['address', 'uint256'], 'bool'), - ('transfer', ['address', 'uint256', 'bytes'], 'bool'), - ('transfer', ['address', 'uint256', 'bytes', 'string'], 'bool')] + +ERC223_transfer_event = ERC_EVENT("Transfer", ["address", "address", "uint256", "bytes"], [True, True, False, False]) + +ERC223_EVENTS = [ERC223_transfer_event] + +ERC223 = [ERC('name', [], 'string', True, True, []), + ERC('symbol', [], 'string', True, True, []), + ERC('decimals', [], 'uint8', True, True, []), + ERC('totalSupply', [], 'uint256', True, True, []), + ERC('balanceOf', ['address'], 'uint256', True, True, []), + ERC('transfer', ['address', 'uint256'], 'bool', False, True, [ERC223_transfer_event]), + ERC('transfer', ['address', 'uint256', 'bytes'], 'bool', False, True, [ERC223_transfer_event]), + ERC('transfer', ['address', 'uint256', 'bytes', 'string'], 'bool', False, True, [ERC223_transfer_event])] ERC223_signatures = erc_to_signatures(ERC223) # Final # https://eips.ethereum.org/EIPS/eip-165 -ERC165 = [('supportsInterface', ['bytes4'], 'bool')] + +ERC165_EVENTS = [] + +ERC165 = [ERC('supportsInterface', ['bytes4'], 'bool', True, True, [])] ERC165_signatures = erc_to_signatures(ERC165) # Final # https://eips.ethereum.org/EIPS/eip-721 # Must have ERC165 -# name, symbol, tokenURI are optionals -ERC721 = [('balanceOf', ['address'], 'uint256'), - ('ownerOf', ['uint256'], 'address'), - ('safeTransferFrom', ['address', 'address', 'uint256', 'bytes'], ''), - ('safeTransferFrom', ['address', 'address', 'uint256'], ''), - ('transferFrom', ['address', 'address', 'uint256'], ''), - ('approve', ['address', 'uint256'], ''), - ('setApprovalForAll', ['address', 'bool'], ''), - ('getApproved', ['uint256'], 'address'), - ('isApprovedForAll', ['address', 'address'], 'bool')] + ERC165 + +ERC721_transfer_event = ERC_EVENT("Transfer", ["address", "address", "uint256"], [True, True, True]) +ERC721_approval_event = ERC_EVENT("Approval", ["address", "address", "uint256"], [True, True, True]) +ERC721_approvalforall_event = ERC_EVENT("ApprovalForAll", ["address", "address", "bool"], [True, True, False]) +ERC721_EVENTS = [ERC721_transfer_event, ERC721_approval_event, ERC721_approvalforall_event] + +ERC721 = [ERC('balanceOf', ['address'], 'uint256', True, True, []), + ERC('ownerOf', ['uint256'], 'address', True, True, []), + ERC('safeTransferFrom', ['address', 'address', 'uint256', 'bytes'], '', False, True, [ERC721_transfer_event]), + ERC('safeTransferFrom', ['address', 'address', 'uint256'], '', False, True, [ERC721_transfer_event]), + ERC('transferFrom', ['address', 'address', 'uint256'], '', False, True, [ERC721_transfer_event]), + ERC('approve', ['address', 'uint256'], '', False, True, [ERC721_approval_event]), + ERC('setApprovalForAll', ['address', 'bool'], '', False, True, [ERC721_approvalforall_event]), + ERC('getApproved', ['uint256'], 'address', True, True, []), + ERC('isApprovedForAll', ['address', 'address'], 'bool', True, True, [])] + ERC165 + +ERC721_OPTIONAL = [ERC('name', [], 'string', True, False, []), + ERC('symbol', [], 'string', False, False, []), + ERC('tokenURI', ['uint256'], 'string', False, False, [])] + +ERC721 = ERC721 + ERC721_OPTIONAL + ERC721_signatures = erc_to_signatures(ERC721) # Final # https://eips.ethereum.org/EIPS/eip-1820 -ERC1820 = [('canImplementInterfaceForAddress', ['bytes32', 'address'], 'bytes32')] +ERC1820_EVENTS = [] +ERC1820 = [ERC('canImplementInterfaceForAddress', ['bytes32', 'address'], 'bytes32', True, True, [])] ERC1820_signatures = erc_to_signatures(ERC1820) # Last Call # https://eips.ethereum.org/EIPS/eip-777 -ERC777 = [('name', [], 'string'), - ('symbol', [], 'string'), - ('totalSupply', [], 'uint256'), - ('balanceOf', ['address'], 'uint256'), - ('granularity', [], 'uint256'), - ('defaultOperators', [], 'address[]'), - ('isOperatorFor', ['address', 'address'], 'bool'), - ('authorizeOperator', ['address'], ''), - ('revokeOperator', ['address'], ''), - ('send', ['address', 'uint256', 'bytes'], ''), - ('operatorSend', ['address', 'address', 'uint256', 'bytes', 'bytes'], ''), - ('burn', ['uint256', 'bytes'] , ''), - ('operatorBurn', ['address', 'uint256', 'bytes', 'bytes'] , '')] -ERC777_signatures = erc_to_signatures(ERC777) \ No newline at end of file +ERC777_sent_event = ERC_EVENT('Sent', + ["address", "address", "address", "uint256", "bytes", "bytes"], + [True, True, True, False, False, False]) +ERC777_minted_event = ERC_EVENT('Minted', + ["address", "address", "uint256", "bytes", "bytes"], + [True, True, False, False, False]) +ERC777_burned_event = ERC_EVENT('Burned', + ["address", "address", "uint256", "bytes", "bytes"], + [True, True, False, False, False]) +ERC777_authorizedOperator_event = ERC_EVENT('AuthorizedOperator', ["address", "address"], [True, True]) +ERC777_revokedoperator_event = ERC_EVENT('RevokedOperator', ["address", "address"], [True, True]) +ERC777_EVENTS = [ERC777_sent_event, ERC777_minted_event, ERC777_burned_event, + ERC777_authorizedOperator_event, ERC777_revokedoperator_event] + +ERC777 = [ERC('name', [], 'string', True, True, []), + ERC('symbol', [], 'string', True, True, []), + ERC('totalSupply', [], 'uint256', True, True, []), + ERC('balanceOf', ['address'], 'uint256', True, True, []), + ERC('granularity', [], 'uint256', True, True, []), + ERC('defaultOperators', [], 'address[]', True, True, []), + ERC('isOperatorFor', ['address', 'address'], 'bool', True, True, []), + ERC('authorizeOperator', ['address'], '', False, True, [ERC777_authorizedOperator_event]), + ERC('revokeOperator', ['address'], '', False, True, [ERC777_revokedoperator_event]), + ERC('send', ['address', 'uint256', 'bytes'], '', False, True, [ERC777_sent_event]), + ERC('operatorSend', ['address', 'address', 'uint256', 'bytes', 'bytes'], '', False, True, [ERC777_sent_event]), + ERC('burn', ['uint256', 'bytes'] , '', False, True, [ERC777_burned_event]), + ERC('operatorBurn', ['address', 'uint256', 'bytes', 'bytes'], '', False, True, [ERC777_burned_event])] +ERC777_signatures = erc_to_signatures(ERC777) + +ERCS = { + "ERC20": (ERC20, ERC20_EVENTS), + "ERC223": (ERC223, ERC223_EVENTS), + "ERC165": (ERC165, ERC165_EVENTS), + "ERC721": (ERC721, ERC721_EVENTS), + "ERC1820": (ERC1820, ERC1820_EVENTS), + "ERC777": (ERC777, ERC777_EVENTS), +} \ No newline at end of file diff --git a/slither/utils/type.py b/slither/utils/type.py index 3b0577987..6939889c8 100644 --- a/slither/utils/type.py +++ b/slither/utils/type.py @@ -32,3 +32,18 @@ def export_nested_types_from_variable(variable): return l +def export_return_type_from_variable(variable): + """ + Return the type returned by a variable + :param variable + :return: Type + """ + if isinstance(variable.type, MappingType): + return export_return_type_from_variable(variable.type.type_to) + + if isinstance(variable.type, ArrayType): + return variable.type.type + + return variable.type + + From 4b8163b040473a0b87b47a3342c5c2c5814db422 Mon Sep 17 00:00:00 2001 From: Josselin Date: Tue, 22 Oct 2019 21:54:36 +0200 Subject: [PATCH 193/223] Add ERC20 approval race condition --- slither/tools/erc_conformance/__main__.py | 15 ++++++-- slither/tools/erc_conformance/erc/erc165.py | 25 -------------- slither/tools/erc_conformance/erc/erc1820.py | 25 -------------- slither/tools/erc_conformance/erc/erc20.py | 36 +++++++++++++------- slither/tools/erc_conformance/erc/erc223.py | 25 -------------- slither/tools/erc_conformance/erc/erc721.py | 25 -------------- slither/tools/erc_conformance/erc/erc777.py | 25 -------------- slither/tools/erc_conformance/erc/ercs.py | 6 ++-- 8 files changed, 38 insertions(+), 144 deletions(-) delete mode 100644 slither/tools/erc_conformance/erc/erc165.py delete mode 100644 slither/tools/erc_conformance/erc/erc1820.py delete mode 100644 slither/tools/erc_conformance/erc/erc223.py delete mode 100644 slither/tools/erc_conformance/erc/erc721.py delete mode 100644 slither/tools/erc_conformance/erc/erc777.py diff --git a/slither/tools/erc_conformance/__main__.py b/slither/tools/erc_conformance/__main__.py index 59043fa06..73b096971 100644 --- a/slither/tools/erc_conformance/__main__.py +++ b/slither/tools/erc_conformance/__main__.py @@ -1,9 +1,12 @@ import argparse import logging +from collections import defaultdict + from slither import Slither from crytic_compile import cryticparser from slither.utils.erc import ERCS from .erc.ercs import generic_erc_checks +from .erc.erc20 import check_erc20 logging.basicConfig() logging.getLogger("Slither").setLevel(logging.INFO) @@ -18,7 +21,9 @@ logger.addHandler(ch) logger.handlers[0].setFormatter(formatter) logger.propagate = False - +ADDITIONAL_CHECKS = { + "ERC20": check_erc20 +} def parse_args(): """ @@ -52,6 +57,8 @@ def main(): # Perform slither analysis on the given filename slither = Slither(args.project, **vars(args)) + ret = defaultdict(list) + if args.erc.upper() in ERCS: contract = slither.get_contract_from_name(args.contract_name) @@ -61,7 +68,11 @@ def main(): return # First elem is the function, second is the event erc = ERCS[args.erc.upper()] - generic_erc_checks(contract, erc[0], erc[1]) + generic_erc_checks(contract, erc[0], erc[1], ret) + + if args.erc.upper() in ADDITIONAL_CHECKS: + ADDITIONAL_CHECKS[args.erc.upper()](contract, ret) + else: logger.error(f'Incorrect ERC selected {args.erc}') return diff --git a/slither/tools/erc_conformance/erc/erc165.py b/slither/tools/erc_conformance/erc/erc165.py deleted file mode 100644 index 4d0e72860..000000000 --- a/slither/tools/erc_conformance/erc/erc165.py +++ /dev/null @@ -1,25 +0,0 @@ -import logging -from collections import defaultdict -from slither.utils.erc import ERC165 -from .ercs import generic_erc_checks -from slither.exceptions import SlitherException - -logger = logging.getLogger("Slither-conformance") - -def check_erc165(slither, contract_name): - - contract = slither.get_contract_from_name(contract_name) - - if not contract: - raise SlitherException(f'{contract_name} not found') - - signatures = generic_erc_checks(contract, ERC165) - - ret = defaultdict(dict) - - ret['erc165'] = { - "signatures": signatures - } - - return ret - diff --git a/slither/tools/erc_conformance/erc/erc1820.py b/slither/tools/erc_conformance/erc/erc1820.py deleted file mode 100644 index e47db9e63..000000000 --- a/slither/tools/erc_conformance/erc/erc1820.py +++ /dev/null @@ -1,25 +0,0 @@ -import logging -from collections import defaultdict -from slither.utils.erc import ERC1820 -from .ercs import generic_erc_checks -from slither.exceptions import SlitherException - -logger = logging.getLogger("Slither-conformance") - -def check_erc1820(slither, contract_name): - - contract = slither.get_contract_from_name(contract_name) - - if not contract: - raise SlitherException(f'{contract_name} not found') - - signatures = generic_erc_checks(contract, ERC1820) - - ret = defaultdict(dict) - - ret['erc1820'] = { - "signatures": signatures - } - - return ret - diff --git a/slither/tools/erc_conformance/erc/erc20.py b/slither/tools/erc_conformance/erc/erc20.py index b02d81b72..42a8dbfef 100644 --- a/slither/tools/erc_conformance/erc/erc20.py +++ b/slither/tools/erc_conformance/erc/erc20.py @@ -1,25 +1,35 @@ import logging -from collections import defaultdict -from slither.utils.erc import ERC20, ERC20_EVENTS -from .ercs import generic_erc_checks -from slither.exceptions import SlitherException logger = logging.getLogger("Slither-conformance") -def check_erc20(slither, contract_name): +def approval_race_condition(contract, ret): + increaseAllowance = contract.get_function_from_signature('increaseAllowance(address,uint256)') - contract = slither.get_contract_from_name(contract_name) + if not increaseAllowance: + increaseAllowance = contract.get_function_from_signature('safeIncreaseAllowance(address,uint256)') - if not contract: - raise SlitherException(f'{contract_name} not found') + if increaseAllowance: + txt = f'\t[✓] {contract.name} has {increaseAllowance.full_name}' + logger.info(txt) + else: + txt = f'\t[ ] {contract.name} is not protected for the ERC20 approval race condition' + ret["lack_of_erc20_race_condition_protection"].append({ + "description": txt, + "contract": contract.name + }) + logger.info(txt) - signatures = generic_erc_checks(contract, ERC20, ERC20_EVENTS) +def check_erc20(contract, ret, explored=None): - ret = defaultdict(dict) + if explored is None: + explored = set() - ret['erc20'] = { - "signatures": signatures - } + explored.add(contract) + + approval_race_condition(contract, ret) + + for derived_contract in contract.derived_contracts: + check_erc20(derived_contract, ret, explored) return ret diff --git a/slither/tools/erc_conformance/erc/erc223.py b/slither/tools/erc_conformance/erc/erc223.py deleted file mode 100644 index 889c5ea5a..000000000 --- a/slither/tools/erc_conformance/erc/erc223.py +++ /dev/null @@ -1,25 +0,0 @@ -import logging -from collections import defaultdict -from slither.utils.erc import ERC223 -from .ercs import generic_erc_checks -from slither.exceptions import SlitherException - -logger = logging.getLogger("Slither-conformance") - -def check_erc223(slither, contract_name): - - contract = slither.get_contract_from_name(contract_name) - - if not contract: - raise SlitherException(f'{contract_name} not found') - - signatures = generic_erc_checks(contract, ERC223) - - ret = defaultdict(dict) - - ret['erc223'] = { - "signatures": signatures - } - - return ret - diff --git a/slither/tools/erc_conformance/erc/erc721.py b/slither/tools/erc_conformance/erc/erc721.py deleted file mode 100644 index 77094e747..000000000 --- a/slither/tools/erc_conformance/erc/erc721.py +++ /dev/null @@ -1,25 +0,0 @@ -import logging -from collections import defaultdict -from slither.utils.erc import ERC721 -from .ercs import generic_erc_checks -from slither.exceptions import SlitherException - -logger = logging.getLogger("Slither-conformance") - -def check_erc721(slither, contract_name): - - contract = slither.get_contract_from_name(contract_name) - - if not contract: - raise SlitherException(f'{contract_name} not found') - - signatures = generic_erc_checks(contract, ERC721) - - ret = defaultdict(dict) - - ret['erc721'] = { - "signatures": signatures - } - - return ret - diff --git a/slither/tools/erc_conformance/erc/erc777.py b/slither/tools/erc_conformance/erc/erc777.py deleted file mode 100644 index ad6ad93cc..000000000 --- a/slither/tools/erc_conformance/erc/erc777.py +++ /dev/null @@ -1,25 +0,0 @@ -import logging -from collections import defaultdict -from slither.utils.erc import ERC777 -from .ercs import generic_erc_checks -from slither.exceptions import SlitherException - -logger = logging.getLogger("Slither-conformance") - -def check_erc777(slither, contract_name): - - contract = slither.get_contract_from_name(contract_name) - - if not contract: - raise SlitherException(f'{contract_name} not found') - - signatures = generic_erc_checks(contract, ERC777) - - ret = defaultdict(dict) - - ret['erc777'] = { - "signatures": signatures - } - - return ret - diff --git a/slither/tools/erc_conformance/erc/ercs.py b/slither/tools/erc_conformance/erc/ercs.py index 8e23caf8e..3b5117420 100644 --- a/slither/tools/erc_conformance/erc/ercs.py +++ b/slither/tools/erc_conformance/erc/ercs.py @@ -174,15 +174,13 @@ def _check_events(erc_event, contract, ret): -def generic_erc_checks(contract, erc_functions, erc_events, explored=None): +def generic_erc_checks(contract, erc_functions, erc_events, ret, explored=None): if explored is None: explored = set() explored.add(contract) - ret = defaultdict(list) - logger.info(f'# Check {contract.name}\n') logger.info(f'## Check functions') @@ -195,4 +193,4 @@ def generic_erc_checks(contract, erc_functions, erc_events, explored=None): logger.info('\n') for derived_contract in contract.derived_contracts: - generic_erc_checks(derived_contract, erc_functions, erc_events, explored) \ No newline at end of file + generic_erc_checks(derived_contract, erc_functions, erc_events, ret, explored) From 6f2c8e713f9ead8b9e2542175bd0f1ff844413e3 Mon Sep 17 00:00:00 2001 From: Josselin Date: Tue, 22 Oct 2019 22:16:34 +0200 Subject: [PATCH 194/223] Upgradeability check: - Fix bug: the json output was always enabled - Move output_json to a shared module --- slither/__main__.py | 28 +---------------- slither/tools/upgradeability/__main__.py | 40 ++---------------------- slither/utils/json_utils.py | 36 +++++++++++++++++++++ 3 files changed, 40 insertions(+), 64 deletions(-) create mode 100644 slither/utils/json_utils.py diff --git a/slither/__main__.py b/slither/__main__.py index 1f02b4b5d..a2b3a395b 100644 --- a/slither/__main__.py +++ b/slither/__main__.py @@ -19,6 +19,7 @@ from slither.detectors.abstract_detector import (AbstractDetector, from slither.printers import all_printers from slither.printers.abstract_printer import AbstractPrinter from slither.slither import Slither +from slither.utils.json_utils import output_json from slither.utils.output_capture import StandardOutputCapture from slither.utils.colors import red, yellow, set_colorization_enabled from slither.utils.command_line import (output_detectors, output_results_to_markdown, @@ -103,33 +104,6 @@ def process_from_asts(filenames, args, detector_classes, printer_classes): -# endregion -################################################################################### -################################################################################### -# region Output -################################################################################### -################################################################################### - - -def output_json(filename, error, results): - # Create our encapsulated JSON result. - json_result = { - "success": error is None, - "error": error, - "results": results - } - - # Determine if we should output to stdout - if filename is None: - # Write json to console - print(json.dumps(json_result)) - else: - # Write json to file - if os.path.isfile(filename): - logger.info(yellow(f'{filename} exists already, the overwrite is prevented')) - else: - with open(filename, 'w', encoding='utf8') as f: - json.dump(json_result, f, indent=2) # endregion ################################################################################### diff --git a/slither/tools/upgradeability/__main__.py b/slither/tools/upgradeability/__main__.py index 74e71ab73..0428fc0d6 100644 --- a/slither/tools/upgradeability/__main__.py +++ b/slither/tools/upgradeability/__main__.py @@ -1,19 +1,16 @@ import logging import argparse import sys -import json -import os from slither import Slither -from slither.utils.colors import red, yellow, set_colorization_enabled from crytic_compile import cryticparser from slither.exceptions import SlitherException +from slither.utils.json_utils import output_json from .compare_variables_order import compare_variables_order_implementation, compare_variables_order_proxy from .compare_function_ids import compare_function_ids from .check_initialization import check_initialization -from collections import OrderedDict logging.basicConfig() logger = logging.getLogger("Slither-check-upgradeability") @@ -47,36 +44,7 @@ def parse_args(): return parser.parse_args() -################################################################################### -################################################################################### -# region Output -################################################################################### -################################################################################### - -def output_json(filename, error, results): - # Create our encapsulated JSON result. - json_result = { - "success": error == None, - "error": error, - "results": { - "upgradeability-check": results - } - } - - # Determine if we should output to stdout - if filename is None: - # Write json to console - print(json.dumps(json_result)) - else: - # Write json to file - if os.path.isfile(filename): - logger.info(yellow(f'{filename} exists already, the overwrite is prevented')) - else: - with open(filename, 'w', encoding='utf8') as f: - json.dump(json_result, f, indent=2) - -# endregion ################################################################################### ################################################################################### # region Main @@ -98,8 +66,6 @@ def main(): # Define some variables for potential JSON output json_results = {} output_error = '' - outputting_json = args.json is not None - outputting_json_stdout = args.json == '-' json_results['check-initialization'] = check_initialization(v1) @@ -133,8 +99,8 @@ def main(): output_error = None # If we are outputting JSON, capture the redirected output and disable the redirect to output the final JSON. - if outputting_json: - output_json(None if outputting_json_stdout else args.json, output_error, json_results) + if args.json: + output_json(args.json, output_error, {"upgradeability-check": json_results}) # endregion diff --git a/slither/utils/json_utils.py b/slither/utils/json_utils.py new file mode 100644 index 000000000..7c92054c7 --- /dev/null +++ b/slither/utils/json_utils.py @@ -0,0 +1,36 @@ +import os +import json +import logging +from slither.utils.colors import yellow +logger = logging.getLogger("Slither") + +def output_json(filename, error, results): + """ + + :param filename: Filename where the json will be written. If None or "-", write to stdout + :param error: Error to report + :param results: Results to report + :param logger: Logger where to log potential info + :return: + """ + # Create our encapsulated JSON result. + json_result = { + "success": error is None, + "error": error, + "results": results + } + + if filename == "-": + filename = None + + # Determine if we should output to stdout + if filename is None: + # Write json to console + print(json.dumps(json_result)) + else: + # Write json to file + if os.path.isfile(filename): + logger.info(yellow(f'{filename} exists already, the overwrite is prevented')) + else: + with open(filename, 'w', encoding='utf8') as f: + json.dump(json_result, f, indent=2) From 5c793c75babb5a7a6d54e405875de42c324ba53d Mon Sep 17 00:00:00 2001 From: Josselin Date: Tue, 22 Oct 2019 22:28:34 +0200 Subject: [PATCH 195/223] Use node 10.17.0 for embark and etherlime --- scripts/travis_test_embark.sh | 4 ++-- scripts/travis_test_etherlime.sh | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/scripts/travis_test_embark.sh b/scripts/travis_test_embark.sh index 1e9d504c9..eeba9f108 100755 --- a/scripts/travis_test_embark.sh +++ b/scripts/travis_test_embark.sh @@ -7,8 +7,8 @@ cd test_embark curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.34.0/install.sh | bash source ~/.nvm/nvm.sh -nvm install --lts -nvm use --lts +nvm install 10.17.0 +nvm use 10.17.0 npm --version npm install -g embark diff --git a/scripts/travis_test_etherlime.sh b/scripts/travis_test_etherlime.sh index 226dbba66..d0b5b43cc 100755 --- a/scripts/travis_test_etherlime.sh +++ b/scripts/travis_test_etherlime.sh @@ -7,8 +7,8 @@ cd test_etherlime curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.34.0/install.sh | bash source ~/.nvm/nvm.sh -nvm install --lts -nvm use --lts +nvm install 10.17.0 +nvm use 10.17.0 npm i -g etherlime etherlime init From f81ff8f196b40ac4655d1c260990dda46d3987d3 Mon Sep 17 00:00:00 2001 From: Josselin Date: Tue, 22 Oct 2019 22:49:41 +0200 Subject: [PATCH 196/223] Check upgradeability: fix typo in unit test --- tests/check-upgradeability/test_5.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/check-upgradeability/test_5.txt b/tests/check-upgradeability/test_5.txt index fc7bf6e2c..89ae5c568 100644 --- a/tests/check-upgradeability/test_5.txt +++ b/tests/check-upgradeability/test_5.txt @@ -1,7 +1,7 @@ INFO:CheckInitialization:Run initialization checks... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#initialization-checks) INFO:CheckInitialization:Contract_lack_to_call_modifier.initialize() does not call initializer INFO:CheckInitialization:Missing call to Contract_no_bug.initialize() in Contract_not_called_super_init -INFO:CheckInitialization:Contract_no_bug.initialize() is called multiple time in Contract_double_call +INFO:CheckInitialization:Contract_no_bug.initialize() is called multiples time in Contract_double_call INFO:CheckInitialization:Check the deployement script to ensure that these functions are called: Contract_no_bug needs to be initialized by initialize() Contract_lack_to_call_modifier needs to be initialized by initialize() From 7756c0e5e00e4216e1693fc5bf44b0d1afecb062 Mon Sep 17 00:00:00 2001 From: Josselin Date: Tue, 22 Oct 2019 22:59:11 +0200 Subject: [PATCH 197/223] Minor --- tests/check-upgradeability/test_5.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/check-upgradeability/test_5.txt b/tests/check-upgradeability/test_5.txt index 89ae5c568..46c52df60 100644 --- a/tests/check-upgradeability/test_5.txt +++ b/tests/check-upgradeability/test_5.txt @@ -1,7 +1,7 @@ INFO:CheckInitialization:Run initialization checks... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#initialization-checks) INFO:CheckInitialization:Contract_lack_to_call_modifier.initialize() does not call initializer INFO:CheckInitialization:Missing call to Contract_no_bug.initialize() in Contract_not_called_super_init -INFO:CheckInitialization:Contract_no_bug.initialize() is called multiples time in Contract_double_call +INFO:CheckInitialization:Contract_no_bug.initialize() is called multiple times in Contract_double_call INFO:CheckInitialization:Check the deployement script to ensure that these functions are called: Contract_no_bug needs to be initialized by initialize() Contract_lack_to_call_modifier needs to be initialized by initialize() From cb1964387b8d4bfd81369349dc40d4937094940c Mon Sep 17 00:00:00 2001 From: Josselin Date: Fri, 25 Oct 2019 09:56:21 +0200 Subject: [PATCH 198/223] Fix incorrect erc20.decimals type --- slither/utils/erc.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/slither/utils/erc.py b/slither/utils/erc.py index 7b40e5b40..4226cdf87 100644 --- a/slither/utils/erc.py +++ b/slither/utils/erc.py @@ -29,7 +29,7 @@ ERC20 = [ERC('totalSupply', [], 'uint256', True, True, []), ERC20_OPTIONAL = [ERC('name', [], 'string', True, False, []), ERC('symbol', [], 'string', True, False, []), - ERC('decimals', [], 'string', True, False, [])] + ERC('decimals', [], 'uint8', True, False, [])] ERC20 = ERC20 + ERC20_OPTIONAL From 6229693830f4beabad4be9646d4a98e1befcc08d Mon Sep 17 00:00:00 2001 From: Josselin Date: Fri, 25 Oct 2019 10:11:08 +0200 Subject: [PATCH 199/223] Remove shadowed function from contract summary --- slither/core/declarations/contract.py | 7 ++++--- slither/printers/summary/contract.py | 2 +- 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/slither/core/declarations/contract.py b/slither/core/declarations/contract.py index 23317c6ce..bb96a25c4 100644 --- a/slither/core/declarations/contract.py +++ b/slither/core/declarations/contract.py @@ -640,14 +640,15 @@ class Contract(ChildSlither, SourceMapping): ################################################################################### ################################################################################### - def get_summary(self): + def get_summary(self, include_shadowed=True): """ Return the function summary + :param include_shadowed: boolean to indicate if shadowed functions should be included (default True) Returns: (str, list, list, list, list): (name, inheritance, variables, fuction summaries, modifier summaries) """ - func_summaries = [f.get_summary() for f in self.functions] - modif_summaries = [f.get_summary() for f in self.modifiers] + func_summaries = [f.get_summary() for f in self.functions if (not f.is_shadowed or include_shadowed)] + modif_summaries = [f.get_summary() for f in self.modifiers if (not f.is_shadowed or include_shadowed)] return (self.name, [str(x) for x in self.inheritance], [str(x) for x in self.variables], func_summaries, modif_summaries) def is_signature_only(self): diff --git a/slither/printers/summary/contract.py b/slither/printers/summary/contract.py index 908fa2599..63a13fb95 100644 --- a/slither/printers/summary/contract.py +++ b/slither/printers/summary/contract.py @@ -21,7 +21,7 @@ class ContractSummary(AbstractPrinter): txt = "" for c in self.contracts: - (name, _inheritance, _var, func_summaries, _modif_summaries) = c.get_summary() + (name, _inheritance, _var, func_summaries, _modif_summaries) = c.get_summary(False) txt += blue("\n+ Contract %s\n"%name) # (c_name, f_name, visi, _, _, _, _, _) in func_summaries public = [(elem[0], (elem[1], elem[2]) ) for elem in func_summaries] From ae31524d07ca9b0298feacd40e47dce44eacdf48 Mon Sep 17 00:00:00 2001 From: Josselin Date: Sat, 26 Oct 2019 09:25:45 +0200 Subject: [PATCH 200/223] Refactor slither-upgradeability-check: - Only the logic contract is needed, proxy becomes optional - Change flag name - Clean main to ease the add of new checks - Clean variable ordering logic; merge the two function into one generic (fix #274) - Refactor json output and add source mapping (fix #347). The json output needs to be tested - Add check for constant conformance (fix #188) - Overall output improvements --- scripts/travis_test_upgradability.sh | 82 +++++++- slither/core/declarations/contract.py | 10 + slither/tools/upgradeability/__main__.py | 198 +++++++++++++----- .../upgradeability/check_initialization.py | 156 +++++++++----- .../check_variable_initialization.py | 35 ++++ .../upgradeability/compare_function_ids.py | 47 ++--- .../upgradeability/compare_variables_order.py | 171 ++++++--------- .../tools/upgradeability/constant_checks.py | 70 +++++++ tests/check-upgradeability/test_1.txt | 19 +- tests/check-upgradeability/test_2.txt | 35 +++- tests/check-upgradeability/test_3.txt | 43 +++- tests/check-upgradeability/test_4.txt | 43 +++- tests/check-upgradeability/test_5.txt | 30 +-- 13 files changed, 644 insertions(+), 295 deletions(-) create mode 100644 slither/tools/upgradeability/check_variable_initialization.py create mode 100644 slither/tools/upgradeability/constant_checks.py diff --git a/scripts/travis_test_upgradability.sh b/scripts/travis_test_upgradability.sh index d840a2fb3..1e1dad3c9 100755 --- a/scripts/travis_test_upgradability.sh +++ b/scripts/travis_test_upgradability.sh @@ -4,7 +4,7 @@ DIR_TESTS="tests/check-upgradeability" -slither-check-upgradeability "$DIR_TESTS/proxy.sol" Proxy "$DIR_TESTS/contractV1.sol" ContractV1 --solc solc-0.5.0 > test_1.txt 2>&1 +slither-check-upgradeability "$DIR_TESTS/contractV1.sol" ContractV1 --proxy-filename "$DIR_TESTS/proxy.sol" --proxy-name Proxy --solc solc-0.5.0 > test_1.txt 2>&1 DIFF=$(diff test_1.txt "$DIR_TESTS/test_1.txt") if [ "$DIFF" != "" ] then @@ -15,7 +15,7 @@ then exit -1 fi -slither-check-upgradeability "$DIR_TESTS/proxy.sol" Proxy "$DIR_TESTS/contractV1.sol" ContractV1 --solc solc-0.5.0 --new-version "$DIR_TESTS/contractV2.sol" --new-contract-name ContractV2 > test_2.txt 2>&1 +slither-check-upgradeability "$DIR_TESTS/contractV1.sol" ContractV1 --proxy-filename "$DIR_TESTS/proxy.sol" --proxy-name Proxy --solc solc-0.5.0 --new-contract-filename "$DIR_TESTS/contractV2.sol" --new-contract-name ContractV2 > test_2.txt 2>&1 DIFF=$(diff test_2.txt "$DIR_TESTS/test_2.txt") if [ "$DIFF" != "" ] then @@ -26,7 +26,7 @@ then exit -1 fi -slither-check-upgradeability "$DIR_TESTS/proxy.sol" Proxy "$DIR_TESTS/contractV1.sol" ContractV1 --solc solc-0.5.0 --new-version "$DIR_TESTS/contractV2_bug.sol" --new-contract-name ContractV2 > test_3.txt 2>&1 +slither-check-upgradeability "$DIR_TESTS/contractV1.sol" ContractV1 --proxy-filename "$DIR_TESTS/proxy.sol" --proxy-name Proxy --solc solc-0.5.0 --new-contract-filename "$DIR_TESTS/contractV2_bug.sol" --new-contract-name ContractV2 > test_3.txt 2>&1 DIFF=$(diff test_3.txt "$DIR_TESTS/test_3.txt") if [ "$DIFF" != "" ] then @@ -37,7 +37,7 @@ then exit -1 fi -slither-check-upgradeability "$DIR_TESTS/proxy.sol" Proxy "$DIR_TESTS/contractV1.sol" ContractV1 --solc solc-0.5.0 --new-version "$DIR_TESTS/contractV2_bug2.sol" --new-contract-name ContractV2 > test_4.txt 2>&1 +slither-check-upgradeability "$DIR_TESTS/contractV1.sol" ContractV1 --proxy-filename "$DIR_TESTS/proxy.sol" --proxy-name Proxy --solc solc-0.5.0 --new-contract-filename "$DIR_TESTS/contractV2_bug2.sol" --new-contract-name ContractV2 > test_4.txt 2>&1 DIFF=$(diff test_4.txt "$DIR_TESTS/test_4.txt") if [ "$DIFF" != "" ] then @@ -48,7 +48,7 @@ then exit -1 fi -slither-check-upgradeability "$DIR_TESTS/proxy.sol" Proxy "$DIR_TESTS/contract_initialization.sol" Contract_no_bug --solc solc-0.5.0 > test_5.txt 2>&1 +slither-check-upgradeability "$DIR_TESTS/contract_initialization.sol" Contract_no_bug --proxy-filename "$DIR_TESTS/proxy.sol" --proxy-name Proxy --solc solc-0.5.0 > test_5.txt 2>&1 DIFF=$(diff test_5.txt "$DIR_TESTS/test_5.txt") if [ "$DIFF" != "" ] then @@ -61,9 +61,81 @@ then exit -1 fi +slither-check-upgradeability "$DIR_TESTS/contract_initialization.sol" Contract_no_bug --proxy-filename "$DIR_TESTS/proxy.sol" --proxy-name Proxy --solc solc-0.5.0 > test_5.txt 2>&1 +DIFF=$(diff test_5.txt "$DIR_TESTS/test_5.txt") +if [ "$DIFF" != "" ] +then + echo "slither-check-upgradeability 5 failed" + cat test_5.txt + echo "" + cat "$DIR_TESTS/test_5.txt" + echo "" + echo "$DIFF" + exit -1 +fi + + +slither-check-upgradeability "$DIR_TESTS/contract_initialization.sol" Contract_lack_to_call_modifier --proxy-filename "$DIR_TESTS/proxy.sol" --proxy-name Proxy --solc solc-0.5.0 > test_6.txt 2>&1 +DIFF=$(diff test_6.txt "$DIR_TESTS/test_6.txt") +if [ "$DIFF" != "" ] +then + echo "slither-check-upgradeability 6 failed" + cat test_6.txt + echo "" + cat "$DIR_TESTS/test_6.txt" + echo "" + echo "$DIFF" + exit -1 +fi + + +slither-check-upgradeability "$DIR_TESTS/contract_initialization.sol" Contract_not_called_super_init --proxy-filename "$DIR_TESTS/proxy.sol" --proxy-name Proxy --solc solc-0.5.0 > test_7.txt 2>&1 +DIFF=$(diff test_7.txt "$DIR_TESTS/test_7.txt") +if [ "$DIFF" != "" ] +then + echo "slither-check-upgradeability 7 failed" + cat test_7.txt + echo "" + cat "$DIR_TESTS/test_7.txt" + echo "" + echo "$DIFF" + exit -1 +fi + +slither-check-upgradeability "$DIR_TESTS/contract_initialization.sol" Contract_no_bug_inherits --proxy-filename "$DIR_TESTS/proxy.sol" --proxy-name Proxy --solc solc-0.5.0 > test_8.txt 2>&1 +DIFF=$(diff test_8.txt "$DIR_TESTS/test_8.txt") +if [ "$DIFF" != "" ] +then + echo "slither-check-upgradeability 8 failed" + cat test_8.txt + echo "" + cat "$DIR_TESTS/test_8.txt" + echo "" + echo "$DIFF" + exit -1 +fi + +slither-check-upgradeability "$DIR_TESTS/contract_initialization.sol" Contract_double_call --proxy-filename "$DIR_TESTS/proxy.sol" --proxy-name Proxy --solc solc-0.5.0 > test_9.txt 2>&1 +DIFF=$(diff test_9.txt "$DIR_TESTS/test_9.txt") +if [ "$DIFF" != "" ] +then + echo "slither-check-upgradeability 9 failed" + cat test_9.txt + echo "" + cat "$DIR_TESTS/test_9.txt" + echo "" + echo "$DIFF" + exit -1 +fi + + rm test_1.txt rm test_2.txt rm test_3.txt rm test_4.txt rm test_5.txt +rm test_6.txt +rm test_7.txt +rm test_8.txt +rm test_9.txt diff --git a/slither/core/declarations/contract.py b/slither/core/declarations/contract.py index bb96a25c4..740fef38e 100644 --- a/slither/core/declarations/contract.py +++ b/slither/core/declarations/contract.py @@ -508,6 +508,16 @@ class Contract(ChildSlither, SourceMapping): """ return next((v for v in self.state_variables if v.name == variable_name), None) + def get_state_variable_from_canonical_name(self, canonical_name): + """ + Return a state variable from a canonical_name + Args: + canonical_name (str): name of the variable + Returns: + StateVariable + """ + return next((v for v in self.state_variables if v.name == canonical_name), None) + def get_structure_from_name(self, structure_name): """ Return a structure from a name diff --git a/slither/tools/upgradeability/__main__.py b/slither/tools/upgradeability/__main__.py index 0428fc0d6..069d0f437 100644 --- a/slither/tools/upgradeability/__main__.py +++ b/slither/tools/upgradeability/__main__.py @@ -1,35 +1,44 @@ import logging import argparse import sys +from collections import defaultdict from slither import Slither from crytic_compile import cryticparser from slither.exceptions import SlitherException from slither.utils.json_utils import output_json -from .compare_variables_order import compare_variables_order_implementation, compare_variables_order_proxy +from .compare_variables_order import compare_variables_order from .compare_function_ids import compare_function_ids from .check_initialization import check_initialization - +from .check_variable_initialization import check_variable_initialization +from .constant_checks import constant_conformance_check logging.basicConfig() logger = logging.getLogger("Slither-check-upgradeability") logger.setLevel(logging.INFO) +ch = logging.StreamHandler() +ch.setLevel(logging.INFO) +formatter = logging.Formatter('%(message)s') +logger.addHandler(ch) +logger.handlers[0].setFormatter(formatter) +logger.propagate = False + def parse_args(): parser = argparse.ArgumentParser(description='Slither Upgradeability Checks. For usage information see https://github.com/crytic/slither/wiki/Upgradeability-Checks.', - usage="slither-check-upgradeability proxy.sol ProxyName implem.sol ContractName") + usage="slither-check-upgradeability contract.sol ContractName") - parser.add_argument('proxy.sol', help='Proxy filename') - parser.add_argument('ProxyName', help='Contract name') + parser.add_argument('contract.sol', help='Codebase to analyze') + parser.add_argument('ContractName', help='Contract name (logic contract)') - parser.add_argument('implem.sol', help='Implementation filename') - parser.add_argument('ContractName', help='Contract name') + parser.add_argument('--proxy-name', help='Proxy name') + parser.add_argument('--proxy-filename', help='Proxy filename (if different)') - parser.add_argument('--new-version', help='New implementation filename') parser.add_argument('--new-contract-name', help='New contract name (if changed)') + parser.add_argument('--new-contract-filename', help='New implementation filename (if different)') parser.add_argument('--json', help='Export the results as a JSON file ("--json -" to export to stdout)', @@ -45,6 +54,52 @@ def parse_args(): return parser.parse_args() +################################################################################### +################################################################################### +# region +################################################################################### +################################################################################### + +def _checks_on_contract(contract, json_results): + """ + + :param contract: + :param json_results: + :return: + """ + json_results['check-initialization'][contract.name] = check_initialization(contract) + json_results['variable-initialization'][contract.name] = check_variable_initialization(contract) + + +def _checks_on_contract_update(contract_v1, contract_v2, json_results): + """ + + :param contract_v1: + :param contract_v2: + :param json_results: + :return: + """ + ret = compare_variables_order(contract_v1, contract_v2) + json_results['compare-variables-order-implementation'][contract_v1.name][contract_v2.name] = ret + + json_results['constant_conformance'][contract_v1.name][contract_v2.name] = constant_conformance_check(contract_v1, + contract_v2) + + +def _checks_on_contract_and_proxy(contract, proxy, json_results, missing_variable_check=True): + """ + + :param contract: + :param proxy: + :param json_results: + :return: + """ + json_results['compare-function-ids'][contract.name] = compare_function_ids(contract, proxy) + json_results['compare-variables-order-proxy'][contract.name] = compare_variables_order(contract, + proxy, + missing_variable_check) + +# endregion ################################################################################### ################################################################################### # region Main @@ -53,54 +108,85 @@ def parse_args(): def main(): + json_results = { + 'check-initialization': defaultdict(dict), + 'variable-initialization': defaultdict(dict), + 'compare-function-ids': defaultdict(dict), + 'compare-variables-order-implementation': defaultdict(dict), + 'compare-variables-order-proxy': defaultdict(dict), + 'constant_conformance': defaultdict(dict), + 'proxy-present': False, + 'contract_v2-present': False + } + args = parse_args() - proxy_filename = vars(args)['proxy.sol'] - proxy = Slither(proxy_filename, **vars(args)) - proxy_name = args.ProxyName - - v1_filename = vars(args)['implem.sol'] - v1 = Slither(v1_filename, **vars(args)) - v1_name = args.ContractName - - # Define some variables for potential JSON output - json_results = {} - output_error = '' - - json_results['check-initialization'] = check_initialization(v1) - - if not args.new_version: - json_results['compare-function-ids'] = compare_function_ids(v1, v1_name, proxy, proxy_name) - json_results['compare-variables-order-proxy'] = compare_variables_order_proxy(v1, v1_name, proxy, proxy_name) - else: - v2 = Slither(args.new_version, **vars(args)) - v2_name = v1_name if not args.new_contract_name else args.new_contract_name - - json_results['check-initialization-v2'] = check_initialization(v2) - - json_results['compare-function-ids'] = compare_function_ids(v2, v2_name, proxy, proxy_name) - - results = {} - output_error = '' - - try: - results = compare_variables_order_proxy(v2, v2_name, proxy, proxy_name) - except SlitherException as se: - output_error = str(se) - json_results['compare-variables-order-proxy'] = results - - try: - results = compare_variables_order_implementation(v1, v1_name, v2, v2_name) - except SlitherException as se: - output_error += str(se) - json_results['compare-variables-order-implementation'] = results - - if output_error == '': - output_error = None - - # If we are outputting JSON, capture the redirected output and disable the redirect to output the final JSON. - if args.json: - output_json(args.json, output_error, {"upgradeability-check": json_results}) - - + v1_filename = vars(args)['contract.sol'] + + try: + v1 = Slither(v1_filename, **vars(args)) + + # Analyze logic contract + v1_name = args.ContractName + v1_contract = v1.get_contract_from_name(v1_name) + if v1_contract is None: + info = 'Contract {} not found in {}'.format(v1_name, v1.filename) + logger.error(info) + if args.json: + output_json(args.json, str(info), {"upgradeability-check": json_results}) + return + + _checks_on_contract(v1_contract, json_results) + + # Analyze Proxy + proxy_contract = None + if args.proxy_name: + if args.proxy_filename: + proxy = Slither(args.proxy_filename, **vars(args)) + else: + proxy = v1 + + proxy_contract = proxy.get_contract_from_name(args.proxy_name) + if proxy_contract is None: + info = 'Proxy {} not found in {}'.format(args.proxy_name, proxy.filename) + logger.error(info) + if args.json: + output_json(args.json, str(info), {"upgradeability-check": json_results}) + return + json_results['proxy-present'] = True + _checks_on_contract_and_proxy(v1_contract, proxy_contract, json_results) + + # Analyze new version + if args.new_contract_name: + if args.new_contract_filename: + v2 = Slither(args.new_contract_filename, **vars(args)) + else: + v2 = v1 + + v2_contract = v2.get_contract_from_name(args.new_contract_name) + if v2_contract is None: + info = 'New logic contract {} not found in {}'.format(args.new_contract_name, v2.filename) + logger.error(info) + if args.json: + output_json(args.json, str(info), {"upgradeability-check": json_results}) + return + json_results['contract_v2-present'] = True + + if proxy_contract: + _checks_on_contract_and_proxy(v2_contract, + proxy_contract, + json_results, + missing_variable_check=False) + + _checks_on_contract_update(v1_contract, v2_contract, json_results) + + if args.json: + output_json(args.json, None, {"upgradeability-check": json_results}) + + except SlitherException as e: + logger.error(str(e)) + if args.json: + output_json(args.json, str(e), {"upgradeability-check": json_results}) + return + # endregion diff --git a/slither/tools/upgradeability/check_initialization.py b/slither/tools/upgradeability/check_initialization.py index 442b68aa2..431ef800a 100644 --- a/slither/tools/upgradeability/check_initialization.py +++ b/slither/tools/upgradeability/check_initialization.py @@ -1,11 +1,9 @@ import logging -from slither import Slither + from slither.slithir.operations import InternalCall -from slither.utils.colors import green,red from slither.utils.colors import red, yellow, green -logger = logging.getLogger("CheckInitialization") -logger.setLevel(logging.INFO) +logger = logging.getLogger("Slither-check-upgradeability") class MultipleInitTarget(Exception): pass @@ -21,69 +19,133 @@ def _get_all_internal_calls(function): def _get_most_derived_init(contract): init_functions = [f for f in contract.functions if not f.is_shadowed and f.name == 'initialize'] if len(init_functions) > 1: + if len([f for f in init_functions if f.contract_declarer == contract]) == 1: + return next((f for f in init_functions if f.contract_declarer == contract)) raise MultipleInitTarget if init_functions: return init_functions[0] return None -def check_initialization(s): +def check_initialization(contract): + + results = { + 'Initializable-present': False, + 'Initializable-inherited': False, + 'Initializable.initializer()-present': False, + 'missing-initializer-modifier': [], + 'initialize_target': {}, + 'missing-calls': [], + 'multiple-calls': [] + } - results = {} - - initializable = s.get_contract_from_name('Initializable') + error_found = False - logger.info(green('Run initialization checks... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#initialization-checks)')) + logger.info(green( + '\n## Run initialization checks... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#initialization-checks)')) + # Check if the Initializable contract is present + initializable = contract.slither.get_contract_from_name('Initializable') if initializable is None: logger.info(yellow('Initializable contract not found, the contract does not follow a standard initalization schema.')) - results['absent'] = "Initializable contract not found, the contract does not follow a standard initalization schema." return results + results['Initializable-present'] = True - init_info = '' + # Check if the Initializable contract is inherited + if initializable not in contract.inheritance: + logger.info( + yellow('The logic contract does not call the initializer.')) + return results + results['Initializable-inherited'] = True - double_calls_found = False - missing_call = False - initializer_modifier_missing = False + # Check if the Initializable contract is inherited + initializer = contract.get_modifier_from_canonical_name('Initializable.initializer()') + if initializer is None: + logger.info( + yellow('Initializable.initializer() does not exist')) + return results + results['Initializable.initializer()-present'] = True - for contract in s.contracts: - if initializable in contract.inheritance: - initializer = contract.get_modifier_from_canonical_name('Initializable.initializer()') - all_init_functions = _get_initialize_functions(contract) - for f in all_init_functions: - if not initializer in f.modifiers: - initializer_modifier_missing = True - info = f'{f.canonical_name} does not call initializer' - logger.info(red(info)) - results['missing-initializer-call'] = info - most_derived_init = _get_most_derived_init(contract) - if most_derived_init is None: - init_info += f'{contract.name} has no initialize function\n' - continue - else: - init_info += f'{contract.name} needs to be initialized by {most_derived_init.full_name}\n' - all_init_functions_called = _get_all_internal_calls(most_derived_init) + [most_derived_init] - missing_calls = [f for f in all_init_functions if not f in all_init_functions_called] - for f in missing_calls: - info = f'Missing call to {f.canonical_name} in {contract.name}' - logger.info(red(info)) - results['missing-call'] = info - missing_call = True - double_calls = list(set([f for f in all_init_functions_called if all_init_functions_called.count(f) > 1])) - for f in double_calls: - info = f'{f.canonical_name} is called multiple times in {contract.name}' - logger.info(red(info)) - results['multiple-calls'] = info - double_calls_found = True + # Check if a init function lacks the initializer modifier + initializer_modifier_missing = False + all_init_functions = _get_initialize_functions(contract) + for f in all_init_functions: + if not initializer in f.modifiers: + initializer_modifier_missing = True + info = f'{f.canonical_name} does not call the initializer modifier' + logger.info(red(info)) + results['missing-initializer-modifier'].append({ + 'description': info, + 'function': f.full_name, + 'contract': f.contract_declarer.name, + 'source_mapping': f.source_mapping + }) if not initializer_modifier_missing: - logger.info(green('All the init functions have the initiliazer modifier')) + logger.info(green('All the init functions have the initializer modifier')) + + # Check if we can determine the initialize function that will be called + # TODO: handle MultipleInitTarget + try: + most_derived_init = _get_most_derived_init(contract) + except MultipleInitTarget: + logger.info(red('Too many init targets')) + return results - if not double_calls_found: - logger.info(green('No double call to init functions found')) + if most_derived_init is None: + init_info = f'{contract.name} has no initialize function\n' + logger.info(green(init_info)) + results['initialize_target'] = {} + return results + # results['initialize_target'] is set at the end, as we want to print it last + # Check if an initialize function is not called from the most_derived_init function + missing_call = False + all_init_functions_called = _get_all_internal_calls(most_derived_init) + [most_derived_init] + missing_calls = [f for f in all_init_functions if not f in all_init_functions_called] + for f in missing_calls: + info = f'Missing call to {f.canonical_name} in {most_derived_init.canonical_name}' + logger.info(red(info)) + results['missing-calls'].append({ + 'description': info, + 'function': f.full_name, + 'contract': f.contract_declarer.name, + 'source_mapping': f.source_mapping, + 'most_derived_init': most_derived_init.full_name, + 'most_derived_init_contract': most_derived_init.contract_declarer.name, + 'most_derived_init_source_mapping': most_derived_init.source_mapping, + }) + missing_call = True if not missing_call: logger.info(green('No missing call to an init function found')) - logger.info(green('Check the deployement script to ensure that these functions are called:\n'+ init_info)) + # Check if an init function is called multiple times + double_calls = list(set([f for f in all_init_functions_called if all_init_functions_called.count(f) > 1])) + double_calls_found = False + for f in double_calls: + info = f'{f.canonical_name} is called multiple times in {most_derived_init.full_name}' + logger.info(red(info)) + results['multiple-calls'].append({ + 'description': info, + 'function': f.full_name, + 'contract': f.contract_declarer.name, + 'source_mapping': f.source_mapping, + }) + double_calls_found = True + if not double_calls_found: + logger.info(green('No double call to init functions found')) + + # Print the initialize_target info + + init_info = f'{contract.name} needs to be initialized by {most_derived_init.full_name}\n' + logger.info(green('Check the deployement script to ensure that these functions are called:\n' + init_info)) + results['initialize_target'] = { + 'description': init_info, + 'function': most_derived_init.full_name, + 'contract': most_derived_init.contract_declarer.name, + 'source_mapping': most_derived_init.source_mapping + } + + if not error_found: + logger.info(green('No error found')) return results diff --git a/slither/tools/upgradeability/check_variable_initialization.py b/slither/tools/upgradeability/check_variable_initialization.py new file mode 100644 index 000000000..7193e86a3 --- /dev/null +++ b/slither/tools/upgradeability/check_variable_initialization.py @@ -0,0 +1,35 @@ +import logging + +from slither.utils.colors import red, green + +logger = logging.getLogger("Slither-check-upgradeability") + + +def check_variable_initialization(contract): + results = { + 'variables-initialized': [] + } + + logger.info(green( + '\n## Run variable initialization checks... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks)')) + + error_found = False + + for s in contract.state_variables: + if s.initialized and not s.is_constant: + info = f'{s.canonical_name} has an initial value ({s.source_mapping_str})' + logger.info(red(info)) + results['variables-initialized'].append( + { + 'description': info, + 'name': s.name, + 'contract': s.contract.name, + 'source_mapping': s.source_mapping + } + ) + error_found = True + + if not error_found: + logger.info(green('No error found')) + + return results \ No newline at end of file diff --git a/slither/tools/upgradeability/compare_function_ids.py b/slither/tools/upgradeability/compare_function_ids.py index 0869b290c..a3f89ce8e 100644 --- a/slither/tools/upgradeability/compare_function_ids.py +++ b/slither/tools/upgradeability/compare_function_ids.py @@ -8,8 +8,7 @@ from slither import Slither from slither.utils.function import get_function_id from slither.utils.colors import red, green -logger = logging.getLogger("CompareFunctions") -logger.setLevel(logging.INFO) +logger = logging.getLogger("Slither-check-upgradeability") def get_signatures(c): functions = c.functions @@ -20,46 +19,42 @@ def get_signatures(c): return list(set(functions+variables)) -def compare_function_ids(implem, implem_name, proxy, proxy_name): +def compare_function_ids(implem, proxy): - results = {} + results = { + 'function-id-collision':[], + 'shadowing':[], + } - logger.info(green('Run function ids checks... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#functions-ids-checks)')) + logger.info(green('\n## Run function ids checks... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#functions-ids-checks)')) - implem_contract = implem.get_contract_from_name(implem_name) - if implem_contract is None: - info = f'{implem_name} not found in {implem.filename}' - logger.info(red(info)) - results['implementation-contract-not-found'] = info - return results - proxy_contract = proxy.get_contract_from_name(proxy_name) - if proxy_contract is None: - info = f'{proxy_name} not found in {proxy.filename}' - logger.info(red(info)) - results['proxy-contract-not-found'] = info - return results - - signatures_implem = get_signatures(implem_contract) - signatures_proxy = get_signatures(proxy_contract) + signatures_implem = get_signatures(implem) + signatures_proxy = get_signatures(proxy) signatures_ids_implem = {get_function_id(s): s for s in signatures_implem} signatures_ids_proxy = {get_function_id(s): s for s in signatures_proxy} - found = False + error_found = False for (k, _) in signatures_ids_implem.items(): if k in signatures_ids_proxy: - found = True + error_found = True if signatures_ids_implem[k] != signatures_ids_proxy[k]: info = 'Function id collision found {} {}'.format(signatures_ids_implem[k], signatures_ids_proxy[k]) logger.info(red(info)) - results['function-id-collision'] = info + results['function-id-collision'].append({ + 'description': info, + 'function1': signatures_ids_implem[k], + 'function2': signatures_ids_proxy[k], + }) else: info = 'Shadowing between proxy and implementation found {}'.format(signatures_ids_implem[k]) logger.info(red(info)) - results['shadowing'] = info + results['shadowing'].append({ + 'function': signatures_ids_implem[k] + }) - if not found: - logger.info(green('No function ids collision found')) + if not error_found: + logger.info(green('No error found')) return results diff --git a/slither/tools/upgradeability/compare_variables_order.py b/slither/tools/upgradeability/compare_variables_order.py index b02d6466d..fe1d5efd1 100644 --- a/slither/tools/upgradeability/compare_variables_order.py +++ b/slither/tools/upgradeability/compare_variables_order.py @@ -2,118 +2,75 @@ Check if the variables respect the same ordering ''' import logging -from slither import Slither -from slither.utils.function import get_function_id from slither.utils.colors import red, green, yellow -from slither.exceptions import SlitherException -logger = logging.getLogger("VariablesOrder") -logger.setLevel(logging.INFO) - -def compare_variables_order_implementation(v1, contract_name1, v2, contract_name2): - - results = {} - - logger.info(green('Run variables order checks between implementations... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#variables-order-checks)')) - - contract_v1 = v1.get_contract_from_name(contract_name1) - if contract_v1 is None: - info = 'Contract {} not found in {}'.format(contract_name1, v1.filename) - logger.info(red(info)) - raise SlitherException(info) - - contract_v2 = v2.get_contract_from_name(contract_name2) - if contract_v2 is None: - info = 'Contract {} not found in {}'.format(contract_name2, v2.filename) - logger.info(red(info)) - raise SlitherException(info) - - order_v1 = [(variable.name, variable.type) for variable in contract_v1.state_variables if not variable.is_constant] - order_v2 = [(variable.name, variable.type) for variable in contract_v2.state_variables if not variable.is_constant] - - results['missing-variable'] = [] - results['different-variables'] = [] - found = False - for idx in range(0, len(order_v1)): - (v1_name, v1_type) = order_v1[idx] - if len(order_v2) < idx: - info = 'Missing variable in the new version: {} {}'.format(v1_name, v1_type) - logger.info(red(info)) - results['missing-variable'].append(info) +logger = logging.getLogger("Slither-check-upgradeability") + + +def compare_variables_order(contract1, contract2, missing_variable_check=True): + + results = { + 'missing_variables': [], + 'different-variables': [], + 'extra-variables': [] + } + + logger.info(green( + f'\n## Run variables ordering checks between {contract1.name} and {contract2.name}... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#variables-order-checks)')) + + order1 = [variable for variable in contract1.state_variables if not variable.is_constant] + order2 = [variable for variable in contract2.state_variables if not variable.is_constant] + + error_found = False + idx = 0 + for idx in range(0, len(order1)): + variable1 = order1[idx] + if len(order2) <= idx: + if missing_variable_check: + info = f'Variable only in {contract1.name}: {variable1.name} ({variable1.source_mapping_str})' + logger.info(yellow(info)) + results['missing_variables'].append({ + 'description': info, + 'variable': variable1.name, + 'source_mapping': variable1.source_mapping + }) + error_found = True continue - (v2_name, v2_type) = order_v2[idx] - - if (v1_name != v2_name) or (v1_type != v2_type): - found = True - info = 'Different variables between v1 and v2: {} {} -> {} {}'.format(v1_name, v1_type, v2_name, v2_type) - logger.info(red(info)) - results['different-variables'].append(info) - - if len(order_v2) > len(order_v1): - new_variables = order_v2[len(order_v1):] - for (name, t) in new_variables: - logger.info(green('New variable: {} {}'.format(name, t))) - - if not found: - logger.info(green('No variables ordering error found between implementations')) - - return results - -def compare_variables_order_proxy(implem, implem_name, proxy, proxy_name): + variable2 = order2[idx] - results = {} - - logger.info(green('Run variables order checks between the implementation and the proxy... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#variables-order-checks)')) - - contract_implem = implem.get_contract_from_name(implem_name) - if contract_implem is None: - info = 'Contract {} not found in {}'.format(implem_name, implem.filename) - logger.info(red(info)) - raise SlitherException(info) - - contract_proxy = proxy.get_contract_from_name(proxy_name) - if contract_proxy is None: - info = 'Contract {} not found in {}'.format(proxy_name, proxy.filename) - logger.info(red(info)) - raise SlitherException(info) - - order_implem = [(variable.name, variable.type) for variable in contract_implem.state_variables if not variable.is_constant] - order_proxy = [(variable.name, variable.type) for variable in contract_proxy.state_variables if not variable.is_constant] - - - results['extra-variable'] = [] - results['different-variables'] = [] - found = False - for idx in range(0, len(order_proxy)): - (proxy_name, proxy_type) = order_proxy[idx] - if len(order_implem) <= idx: - info = 'Extra variable in the proxy: {} {}'.format(proxy_name, proxy_type) + if (variable1.name != variable2.name) or (variable1.type != variable2.type): + info = f'Different variables between {contract1.name} and {contract2.name}:\n' + info += f'\t Variable {idx} in {contract1.name}: {variable1.name} {variable1.type} ({variable1.source_mapping_str})\n' + info += f'\t Variable {idx} in {contract2.name}: {variable2.name} {variable2.type} ({variable2.source_mapping_str})\n' logger.info(red(info)) - results['extra-variable'].append(info) - continue - (implem_name, implem_type) = order_implem[idx] - - if (proxy_name != implem_name) or (proxy_type != implem_type): - found = True - info = 'Different variables between proxy and implem: {} {} -> {} {}'.format(proxy_name, - proxy_type, - implem_name, - implem_type) - logger.info(red(info)) - results['different-variables'].append(info) - else: - logger.info(yellow('Variable in the proxy: {} {}'.format(proxy_name, - proxy_type))) - - - #if len(order_implem) > len(order_proxy): - # new_variables = order_implem[len(order_proxy):] - # for (name, t) in new_variables: - # logger.info(green('Variable only in implem: {} {}'.format(name, t))) - - if not found: - logger.info(green('No variables ordering error found between implementation and the proxy')) - + results['different-variables'].append({ + 'description': info, + 'index': idx, + 'variable1': variable1.name, + 'variable1_source_mapping': variable1.source_mapping, + 'variable2': variable2.name, + 'variable2_source_mapping': variable2.source_mapping, + }) + error_found = True + + idx = idx + 1 + + while idx < len(order2): + variable2 = order2[idx] + + info = f'Extra variables in {contract2.name}: {variable2.name} ({variable2.source_mapping_str})\n' + logger.info(yellow(info)) + results['extra-variables'].append({ + 'description': info, + 'index': idx, + 'variable': variable2.name, + 'variable_source_mapping': variable2.source_mapping + }) + idx = idx + 1 + + if not error_found: + logger.info(green('No error found')) return results + diff --git a/slither/tools/upgradeability/constant_checks.py b/slither/tools/upgradeability/constant_checks.py new file mode 100644 index 000000000..98847ffc3 --- /dev/null +++ b/slither/tools/upgradeability/constant_checks.py @@ -0,0 +1,70 @@ +import logging + +from slither.utils.colors import red, yellow, green + +logger = logging.getLogger("Slither-check-upgradeability") + +def constant_conformance_check(contract_v1, contract_v2): + + results = { + "became_constants": [], + "were_constants": [], + "not_found_in_v2": [], + } + + logger.info(green( + '\n## Run variable constants conformance check... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks)')) + error_found = False + + state_variables_v1 = contract_v1.state_variables + state_variables_v2 = contract_v2.state_variables + + for idx in range(0, len(state_variables_v1)): + state_v1 = contract_v1.state_variables[idx] + + if len(state_variables_v2) <= idx: + break + + state_v2 = contract_v2.state_variables[idx] + + if state_v2: + if state_v1.is_constant: + if not state_v2.is_constant: + info = f'{state_v1.canonical_name} was constant and {contract_v2.name} is not' + logger.info(red(info)) + results['were_constants'].append({ + 'description': info, + 'contract_v1': contract_v1.name, + 'contract_v2': contract_v2.name, + 'variable': state_v1.name, + 'source_mapping': state_v1.source_mapping + }) + error_found = True + elif state_v2.is_constant: + info = f'{state_v1.canonical_name} was not constant and {contract_v2.name} is' + logger.info(red(info)) + results['became_constants'].append({ + 'description': info, + 'contract_v1': contract_v1.name, + 'contract_v2': contract_v2.name, + 'variable': state_v1.name, + 'source_mapping': state_v1.source_mapping + }) + error_found = True + + else: + info = f'{state_v1.canonical_name} not found in {contract_v2.name}, not check was done' + logger.info(yellow(info)) + results['not_found_in_v2'].append({ + 'description': info, + 'contract_v1': contract_v1.name, + 'contract_v2': contract_v2.name, + 'variable': state_v1.name, + 'source_mapping': state_v1.source_mapping + }) + error_found = True + + if not error_found: + logger.info(green('No error found')) + + return results \ No newline at end of file diff --git a/tests/check-upgradeability/test_1.txt b/tests/check-upgradeability/test_1.txt index 2bb466c54..df22e2702 100644 --- a/tests/check-upgradeability/test_1.txt +++ b/tests/check-upgradeability/test_1.txt @@ -1,7 +1,12 @@ -INFO:CheckInitialization:Run initialization checks... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#initialization-checks) -INFO:CheckInitialization:Initializable contract not found, the contract does not follow a standard initalization schema. -INFO:CompareFunctions:Run function ids checks... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#functions-ids-checks) -INFO:CompareFunctions:No function ids collision found -INFO:VariablesOrder:Run variables order checks between the implementation and the proxy... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#variables-order-checks) -INFO:VariablesOrder:Variable in the proxy: destination address -INFO:VariablesOrder:No variables ordering error found between implementation and the proxy + +## Run initialization checks... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#initialization-checks) +Initializable contract not found, the contract does not follow a standard initalization schema. + +## Run variable initialization checks... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks) +No error found + +## Run function ids checks... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#functions-ids-checks) +No error found + +## Run variables ordering checks between ContractV1 and Proxy... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#variables-order-checks) +No error found diff --git a/tests/check-upgradeability/test_2.txt b/tests/check-upgradeability/test_2.txt index 611c9db4c..9137454fe 100644 --- a/tests/check-upgradeability/test_2.txt +++ b/tests/check-upgradeability/test_2.txt @@ -1,11 +1,24 @@ -INFO:CheckInitialization:Run initialization checks... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#initialization-checks) -INFO:CheckInitialization:Initializable contract not found, the contract does not follow a standard initalization schema. -INFO:CheckInitialization:Run initialization checks... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#initialization-checks) -INFO:CheckInitialization:Initializable contract not found, the contract does not follow a standard initalization schema. -INFO:CompareFunctions:Run function ids checks... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#functions-ids-checks) -INFO:CompareFunctions:No function ids collision found -INFO:VariablesOrder:Run variables order checks between the implementation and the proxy... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#variables-order-checks) -INFO:VariablesOrder:Variable in the proxy: destination address -INFO:VariablesOrder:No variables ordering error found between implementation and the proxy -INFO:VariablesOrder:Run variables order checks between implementations... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#variables-order-checks) -INFO:VariablesOrder:No variables ordering error found between implementations + +## Run initialization checks... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#initialization-checks) +Initializable contract not found, the contract does not follow a standard initalization schema. + +## Run variable initialization checks... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks) +No error found + +## Run function ids checks... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#functions-ids-checks) +No error found + +## Run variables ordering checks between ContractV1 and Proxy... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#variables-order-checks) +No error found + +## Run function ids checks... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#functions-ids-checks) +No error found + +## Run variables ordering checks between ContractV2 and Proxy... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#variables-order-checks) +No error found + +## Run variables ordering checks between ContractV1 and ContractV2... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#variables-order-checks) +No error found + +## Run variable constants conformance check... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks) +No error found diff --git a/tests/check-upgradeability/test_3.txt b/tests/check-upgradeability/test_3.txt index 2954e66c9..bf09a58ac 100644 --- a/tests/check-upgradeability/test_3.txt +++ b/tests/check-upgradeability/test_3.txt @@ -1,11 +1,32 @@ -INFO:CheckInitialization:Run initialization checks... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#initialization-checks) -INFO:CheckInitialization:Initializable contract not found, the contract does not follow a standard initalization schema. -INFO:CheckInitialization:Run initialization checks... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#initialization-checks) -INFO:CheckInitialization:Initializable contract not found, the contract does not follow a standard initalization schema. -INFO:CompareFunctions:Run function ids checks... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#functions-ids-checks) -INFO:CompareFunctions:Shadowing between proxy and implementation found myFunc() -INFO:VariablesOrder:Run variables order checks between the implementation and the proxy... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#variables-order-checks) -INFO:VariablesOrder:Different variables between proxy and implem: destination address -> destination uint256 -INFO:VariablesOrder:Run variables order checks between implementations... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#variables-order-checks) -INFO:VariablesOrder:Different variables between v1 and v2: destination address -> destination uint256 -INFO:VariablesOrder:New variable: myFunc uint256 + +## Run initialization checks... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#initialization-checks) +Initializable contract not found, the contract does not follow a standard initalization schema. + +## Run variable initialization checks... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks) +No error found + +## Run function ids checks... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#functions-ids-checks) +No error found + +## Run variables ordering checks between ContractV1 and Proxy... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#variables-order-checks) +No error found + +## Run function ids checks... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#functions-ids-checks) +Shadowing between proxy and implementation found myFunc() + +## Run variables ordering checks between ContractV2 and Proxy... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#variables-order-checks) +Different variables between ContractV2 and Proxy: + Variable 0 in ContractV2: destination uint256 (tests/check-upgradeability/contractV2_bug.sol#2) + Variable 0 in Proxy: destination address (tests/check-upgradeability/proxy.sol#9) + + +## Run variables ordering checks between ContractV1 and ContractV2... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#variables-order-checks) +Different variables between ContractV1 and ContractV2: + Variable 0 in ContractV1: destination address (tests/check-upgradeability/contractV1.sol#2) + Variable 0 in ContractV2: destination uint256 (tests/check-upgradeability/contractV2_bug.sol#2) + +Extra variables in ContractV2: myFunc (tests/check-upgradeability/contractV2_bug.sol#4) + + +## Run variable constants conformance check... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks) +No error found diff --git a/tests/check-upgradeability/test_4.txt b/tests/check-upgradeability/test_4.txt index 5f9dbb0c7..cf9c9acd6 100644 --- a/tests/check-upgradeability/test_4.txt +++ b/tests/check-upgradeability/test_4.txt @@ -1,11 +1,32 @@ -INFO:CheckInitialization:Run initialization checks... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#initialization-checks) -INFO:CheckInitialization:Initializable contract not found, the contract does not follow a standard initalization schema. -INFO:CheckInitialization:Run initialization checks... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#initialization-checks) -INFO:CheckInitialization:Initializable contract not found, the contract does not follow a standard initalization schema. -INFO:CompareFunctions:Run function ids checks... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#functions-ids-checks) -INFO:CompareFunctions:No function ids collision found -INFO:VariablesOrder:Run variables order checks between the implementation and the proxy... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#variables-order-checks) -INFO:VariablesOrder:Different variables between proxy and implem: destination address -> val uint256 -INFO:VariablesOrder:Run variables order checks between implementations... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#variables-order-checks) -INFO:VariablesOrder:Different variables between v1 and v2: destination address -> val uint256 -INFO:VariablesOrder:New variable: destination address + +## Run initialization checks... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#initialization-checks) +Initializable contract not found, the contract does not follow a standard initalization schema. + +## Run variable initialization checks... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks) +No error found + +## Run function ids checks... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#functions-ids-checks) +No error found + +## Run variables ordering checks between ContractV1 and Proxy... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#variables-order-checks) +No error found + +## Run function ids checks... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#functions-ids-checks) +No error found + +## Run variables ordering checks between ContractV2 and Proxy... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#variables-order-checks) +Different variables between ContractV2 and Proxy: + Variable 0 in ContractV2: val uint256 (tests/check-upgradeability/contractV2_bug2.sol#2) + Variable 0 in Proxy: destination address (tests/check-upgradeability/proxy.sol#9) + + +## Run variables ordering checks between ContractV1 and ContractV2... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#variables-order-checks) +Different variables between ContractV1 and ContractV2: + Variable 0 in ContractV1: destination address (tests/check-upgradeability/contractV1.sol#2) + Variable 0 in ContractV2: val uint256 (tests/check-upgradeability/contractV2_bug2.sol#2) + +Extra variables in ContractV2: destination (tests/check-upgradeability/contractV2_bug2.sol#5) + + +## Run variable constants conformance check... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks) +No error found diff --git a/tests/check-upgradeability/test_5.txt b/tests/check-upgradeability/test_5.txt index 46c52df60..58547b641 100644 --- a/tests/check-upgradeability/test_5.txt +++ b/tests/check-upgradeability/test_5.txt @@ -1,16 +1,18 @@ -INFO:CheckInitialization:Run initialization checks... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#initialization-checks) -INFO:CheckInitialization:Contract_lack_to_call_modifier.initialize() does not call initializer -INFO:CheckInitialization:Missing call to Contract_no_bug.initialize() in Contract_not_called_super_init -INFO:CheckInitialization:Contract_no_bug.initialize() is called multiple times in Contract_double_call -INFO:CheckInitialization:Check the deployement script to ensure that these functions are called: + +## Run initialization checks... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#initialization-checks) +All the init functions have the initializer modifier +No missing call to an init function found +No double call to init functions found +Check the deployement script to ensure that these functions are called: Contract_no_bug needs to be initialized by initialize() -Contract_lack_to_call_modifier needs to be initialized by initialize() -Contract_not_called_super_init needs to be initialized by initialize() -Contract_no_bug_inherits needs to be initialized by initialize() -Contract_double_call needs to be initialized by initialize()  -INFO:CompareFunctions:Run function ids checks... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#functions-ids-checks) -INFO:CompareFunctions:No function ids collision found -INFO:VariablesOrder:Run variables order checks between the implementation and the proxy... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#variables-order-checks) -INFO:VariablesOrder:Variable in the proxy: destination address -INFO:VariablesOrder:No variables ordering error found between implementation and the proxy +No error found + +## Run variable initialization checks... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks) +No error found + +## Run function ids checks... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#functions-ids-checks) +No error found + +## Run variables ordering checks between Contract_no_bug and Proxy... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#variables-order-checks) +No error found From b9602fc6dbb72ece9f81a474f5ba8b2a529eb7f2 Mon Sep 17 00:00:00 2001 From: Josselin Date: Sat, 26 Oct 2019 09:31:32 +0200 Subject: [PATCH 201/223] upgradeability check: remove FP in case of fallback function collision (fix #331) --- slither/tools/upgradeability/compare_function_ids.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/slither/tools/upgradeability/compare_function_ids.py b/slither/tools/upgradeability/compare_function_ids.py index a3f89ce8e..795627160 100644 --- a/slither/tools/upgradeability/compare_function_ids.py +++ b/slither/tools/upgradeability/compare_function_ids.py @@ -12,7 +12,8 @@ logger = logging.getLogger("Slither-check-upgradeability") def get_signatures(c): functions = c.functions - functions = [f.full_name for f in functions if f.visibility in ['public', 'external'] and not f.is_constructor] + functions = [f.full_name for f in functions if f.visibility in ['public', 'external'] and + not f.is_constructor and not f.is_fallback] variables = c.state_variables variables = [variable.name+ '()' for variable in variables if variable.visibility in ['public']] From cb2c6073ec2ed6a8b5630cabf0450baeff8bd8d1 Mon Sep 17 00:00:00 2001 From: Josselin Date: Sat, 26 Oct 2019 10:48:01 +0200 Subject: [PATCH 202/223] Upgradeability checks: - add missing file - Test constant conformance - Test variable initilization - Minor change in output --- scripts/travis_test_upgradability.sh | 28 ++++++++++++++++++- slither/tools/upgradeability/__main__.py | 8 ++++-- .../tools/upgradeability/constant_checks.py | 4 +-- .../contract_v1_var_init.sol | 3 ++ .../contract_v2_constant.sol | 3 ++ tests/check-upgradeability/test_10.txt | 12 ++++++++ tests/check-upgradeability/test_11.txt | 6 ++++ tests/check-upgradeability/test_6.txt | 18 ++++++++++++ tests/check-upgradeability/test_7.txt | 18 ++++++++++++ tests/check-upgradeability/test_8.txt | 18 ++++++++++++ tests/check-upgradeability/test_9.txt | 18 ++++++++++++ 11 files changed, 130 insertions(+), 6 deletions(-) create mode 100644 tests/check-upgradeability/contract_v1_var_init.sol create mode 100644 tests/check-upgradeability/contract_v2_constant.sol create mode 100644 tests/check-upgradeability/test_10.txt create mode 100644 tests/check-upgradeability/test_11.txt create mode 100644 tests/check-upgradeability/test_6.txt create mode 100644 tests/check-upgradeability/test_7.txt create mode 100644 tests/check-upgradeability/test_8.txt create mode 100644 tests/check-upgradeability/test_9.txt diff --git a/scripts/travis_test_upgradability.sh b/scripts/travis_test_upgradability.sh index 1e1dad3c9..610356c92 100755 --- a/scripts/travis_test_upgradability.sh +++ b/scripts/travis_test_upgradability.sh @@ -128,6 +128,31 @@ then exit -1 fi +slither-check-upgradeability "$DIR_TESTS/contractV1.sol" ContractV1 --solc solc-0.5.0 --new-contract-filename "$DIR_TESTS/contract_v2_constant.sol" --new-contract-name ContractV2 > test_10.txt 2>&1 +DIFF=$(diff test_10.txt "$DIR_TESTS/test_10.txt") +if [ "$DIFF" != "" ] +then + echo "slither-check-upgradeability 10 failed" + cat test_10.txt + echo "" + cat "$DIR_TESTS/test_10.txt" + echo "" + echo "$DIFF" + exit -1 +fi + +slither-check-upgradeability "$DIR_TESTS/contract_v1_var_init.sol" ContractV1 --solc solc-0.5.0 > test_11.txt 2>&1 +DIFF=$(diff test_11.txt "$DIR_TESTS/test_11.txt") +if [ "$DIFF" != "" ] +then + echo "slither-check-upgradeability 11 failed" + cat test_11.txt + echo "" + cat "$DIR_TESTS/test_11.txt" + echo "" + echo "$DIFF" + exit -1 +fi rm test_1.txt rm test_2.txt @@ -138,4 +163,5 @@ rm test_6.txt rm test_7.txt rm test_8.txt rm test_9.txt - +rm test_10.txt +rm test_11.txt diff --git a/slither/tools/upgradeability/__main__.py b/slither/tools/upgradeability/__main__.py index 069d0f437..305a43dae 100644 --- a/slither/tools/upgradeability/__main__.py +++ b/slither/tools/upgradeability/__main__.py @@ -6,6 +6,7 @@ from collections import defaultdict from slither import Slither from crytic_compile import cryticparser from slither.exceptions import SlitherException +from slither.utils.colors import red from slither.utils.json_utils import output_json from .compare_variables_order import compare_variables_order @@ -79,6 +80,7 @@ def _checks_on_contract_update(contract_v1, contract_v2, json_results): :param json_results: :return: """ + ret = compare_variables_order(contract_v1, contract_v2) json_results['compare-variables-order-implementation'][contract_v1.name][contract_v2.name] = ret @@ -131,7 +133,7 @@ def main(): v1_contract = v1.get_contract_from_name(v1_name) if v1_contract is None: info = 'Contract {} not found in {}'.format(v1_name, v1.filename) - logger.error(info) + logger.error(red(info)) if args.json: output_json(args.json, str(info), {"upgradeability-check": json_results}) return @@ -149,7 +151,7 @@ def main(): proxy_contract = proxy.get_contract_from_name(args.proxy_name) if proxy_contract is None: info = 'Proxy {} not found in {}'.format(args.proxy_name, proxy.filename) - logger.error(info) + logger.error(red(info)) if args.json: output_json(args.json, str(info), {"upgradeability-check": json_results}) return @@ -166,7 +168,7 @@ def main(): v2_contract = v2.get_contract_from_name(args.new_contract_name) if v2_contract is None: info = 'New logic contract {} not found in {}'.format(args.new_contract_name, v2.filename) - logger.error(info) + logger.error(red(info)) if args.json: output_json(args.json, str(info), {"upgradeability-check": json_results}) return diff --git a/slither/tools/upgradeability/constant_checks.py b/slither/tools/upgradeability/constant_checks.py index 98847ffc3..653842f8d 100644 --- a/slither/tools/upgradeability/constant_checks.py +++ b/slither/tools/upgradeability/constant_checks.py @@ -30,7 +30,7 @@ def constant_conformance_check(contract_v1, contract_v2): if state_v2: if state_v1.is_constant: if not state_v2.is_constant: - info = f'{state_v1.canonical_name} was constant and {contract_v2.name} is not' + info = f'{state_v1.canonical_name} ({state_v1.source_mapping_str}) was constant and {state_v2.canonical_name} is not ({state_v2.source_mapping_str})' logger.info(red(info)) results['were_constants'].append({ 'description': info, @@ -41,7 +41,7 @@ def constant_conformance_check(contract_v1, contract_v2): }) error_found = True elif state_v2.is_constant: - info = f'{state_v1.canonical_name} was not constant and {contract_v2.name} is' + info = f'{state_v1.canonical_name} ({state_v1.source_mapping_str}) was not constant but {state_v2.canonical_name} is ({state_v2.source_mapping_str})' logger.info(red(info)) results['became_constants'].append({ 'description': info, diff --git a/tests/check-upgradeability/contract_v1_var_init.sol b/tests/check-upgradeability/contract_v1_var_init.sol new file mode 100644 index 000000000..df9bb3fa1 --- /dev/null +++ b/tests/check-upgradeability/contract_v1_var_init.sol @@ -0,0 +1,3 @@ +contract ContractV1{ + address destination = address(0x41); +} diff --git a/tests/check-upgradeability/contract_v2_constant.sol b/tests/check-upgradeability/contract_v2_constant.sol new file mode 100644 index 000000000..c985e3f98 --- /dev/null +++ b/tests/check-upgradeability/contract_v2_constant.sol @@ -0,0 +1,3 @@ +contract ContractV2{ + address constant destination = address(0x41); +} diff --git a/tests/check-upgradeability/test_10.txt b/tests/check-upgradeability/test_10.txt new file mode 100644 index 000000000..89589b364 --- /dev/null +++ b/tests/check-upgradeability/test_10.txt @@ -0,0 +1,12 @@ + +## Run initialization checks... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#initialization-checks) +Initializable contract not found, the contract does not follow a standard initalization schema. + +## Run variable initialization checks... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks) +No error found + +## Run variables ordering checks between ContractV1 and ContractV2... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#variables-order-checks) +Variable only in ContractV1: destination (tests/check-upgradeability/contractV1.sol#2) + +## Run variable constants conformance check... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks) +ContractV1.destination (tests/check-upgradeability/contractV1.sol#2) was not constant but ContractV2.destination is (tests/check-upgradeability/contract_v2_constant.sol#2) diff --git a/tests/check-upgradeability/test_11.txt b/tests/check-upgradeability/test_11.txt new file mode 100644 index 000000000..24764c8c5 --- /dev/null +++ b/tests/check-upgradeability/test_11.txt @@ -0,0 +1,6 @@ + +## Run initialization checks... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#initialization-checks) +Initializable contract not found, the contract does not follow a standard initalization schema. + +## Run variable initialization checks... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks) +ContractV1.destination has an initial value (tests/check-upgradeability/contract_v1_var_init.sol#2) diff --git a/tests/check-upgradeability/test_6.txt b/tests/check-upgradeability/test_6.txt new file mode 100644 index 000000000..85da69ae4 --- /dev/null +++ b/tests/check-upgradeability/test_6.txt @@ -0,0 +1,18 @@ + +## Run initialization checks... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#initialization-checks) +Contract_lack_to_call_modifier.initialize() does not call the initializer modifier +No missing call to an init function found +No double call to init functions found +Check the deployement script to ensure that these functions are called: +Contract_lack_to_call_modifier needs to be initialized by initialize() + +No error found + +## Run variable initialization checks... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks) +No error found + +## Run function ids checks... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#functions-ids-checks) +No error found + +## Run variables ordering checks between Contract_lack_to_call_modifier and Proxy... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#variables-order-checks) +No error found diff --git a/tests/check-upgradeability/test_7.txt b/tests/check-upgradeability/test_7.txt new file mode 100644 index 000000000..d2110df9c --- /dev/null +++ b/tests/check-upgradeability/test_7.txt @@ -0,0 +1,18 @@ + +## Run initialization checks... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#initialization-checks) +All the init functions have the initializer modifier +Missing call to Contract_no_bug.initialize() in Contract_not_called_super_init.initialize() +No double call to init functions found +Check the deployement script to ensure that these functions are called: +Contract_not_called_super_init needs to be initialized by initialize() + +No error found + +## Run variable initialization checks... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks) +No error found + +## Run function ids checks... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#functions-ids-checks) +No error found + +## Run variables ordering checks between Contract_not_called_super_init and Proxy... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#variables-order-checks) +No error found diff --git a/tests/check-upgradeability/test_8.txt b/tests/check-upgradeability/test_8.txt new file mode 100644 index 000000000..69ff9ebec --- /dev/null +++ b/tests/check-upgradeability/test_8.txt @@ -0,0 +1,18 @@ + +## Run initialization checks... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#initialization-checks) +All the init functions have the initializer modifier +No missing call to an init function found +No double call to init functions found +Check the deployement script to ensure that these functions are called: +Contract_no_bug_inherits needs to be initialized by initialize() + +No error found + +## Run variable initialization checks... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks) +No error found + +## Run function ids checks... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#functions-ids-checks) +No error found + +## Run variables ordering checks between Contract_no_bug_inherits and Proxy... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#variables-order-checks) +No error found diff --git a/tests/check-upgradeability/test_9.txt b/tests/check-upgradeability/test_9.txt new file mode 100644 index 000000000..3e12a4525 --- /dev/null +++ b/tests/check-upgradeability/test_9.txt @@ -0,0 +1,18 @@ + +## Run initialization checks... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#initialization-checks) +All the init functions have the initializer modifier +No missing call to an init function found +Contract_no_bug.initialize() is called multiple times in initialize() +Check the deployement script to ensure that these functions are called: +Contract_double_call needs to be initialized by initialize() + +No error found + +## Run variable initialization checks... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks) +No error found + +## Run function ids checks... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#functions-ids-checks) +No error found + +## Run variables ordering checks between Contract_double_call and Proxy... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#variables-order-checks) +No error found From 8d32de0472e8bf64b2c0162564dfaf9c938dcbea Mon Sep 17 00:00:00 2001 From: Josselin Date: Sat, 26 Oct 2019 13:10:34 +0200 Subject: [PATCH 203/223] Move json functions to slither.utils.json_utils --- slither/detectors/abstract_detector.py | 176 +--------- .../detectors/attributes/const_functions.py | 8 +- .../detectors/attributes/constant_pragma.py | 3 +- .../detectors/attributes/incorrect_solc.py | 4 +- slither/detectors/attributes/locked_ether.py | 5 +- .../erc/incorrect_erc20_interface.py | 3 +- .../erc/incorrect_erc721_interface.py | 3 +- .../erc/unindexed_event_parameters.py | 3 +- slither/detectors/examples/backdoor.py | 3 +- slither/detectors/functions/arbitrary_send.py | 5 +- .../detectors/functions/complex_function.py | 3 +- .../detectors/functions/external_function.py | 5 +- slither/detectors/functions/suicidal.py | 4 +- .../naming_convention/naming_convention.py | 22 +- .../detectors/operations/block_timestamp.py | 5 +- .../detectors/operations/low_level_calls.py | 5 +- .../operations/unused_return_values.py | 6 +- .../detectors/operations/void_constructor.py | 6 +- .../detectors/reentrancy/reentrancy_benign.py | 9 +- .../detectors/reentrancy/reentrancy_eth.py | 10 +- .../reentrancy_read_before_write.py | 7 +- slither/detectors/shadowing/abstract.py | 3 +- .../detectors/shadowing/builtin_symbols.py | 7 +- slither/detectors/shadowing/local.py | 9 +- slither/detectors/shadowing/state.py | 3 +- slither/detectors/source/rtlo.py | 9 +- slither/detectors/statements/assembly.py | 5 +- slither/detectors/statements/calls_in_loop.py | 3 +- .../statements/controlled_delegatecall.py | 6 +- .../detectors/statements/deprecated_calls.py | 5 +- .../statements/incorrect_strict_equality.py | 6 +- .../detectors/statements/too_many_digits.py | 4 +- slither/detectors/statements/tx_origin.py | 4 +- .../possible_const_state_variables.py | 3 +- .../uninitialized_local_variables.py | 5 +- .../uninitialized_state_variables.py | 5 +- .../uninitialized_storage_variables.py | 5 +- .../variables/unused_state_variables.py | 5 +- slither/utils/json_utils.py | 301 ++++++++++++++++++ 39 files changed, 435 insertions(+), 248 deletions(-) diff --git a/slither/detectors/abstract_detector.py b/slither/detectors/abstract_detector.py index e7911e4c7..6a05c4a5d 100644 --- a/slither/detectors/abstract_detector.py +++ b/slither/detectors/abstract_detector.py @@ -1,8 +1,9 @@ import abc import re -from collections import OrderedDict, defaultdict +from collections import OrderedDict + +from slither.utils import json_utils from slither.utils.colors import green, yellow, red -from slither.core.source_mapping.source_mapping import SourceMapping from slither.formatters.exceptions import FormatImpossible from slither.formatters.utils.patches import apply_patch, create_diff @@ -167,177 +168,14 @@ class AbstractDetector(metaclass=abc.ABCMeta): def color(self): return classification_colors[self.IMPACT] - def generate_json_result(self, info, additional_fields={}): - d = OrderedDict() + def generate_json_result(self, info, additional_fields=None): + d = json_utils.generate_json_result(info, additional_fields) + d['check'] = self.ARGUMENT d['impact'] = classification_txt[self.IMPACT] d['confidence'] = classification_txt[self.CONFIDENCE] - d['description'] = info - d['elements'] = [] - if additional_fields: - d['additional_fields'] = additional_fields - return d - @staticmethod - def _create_base_element(type, name, source_mapping, type_specific_fields={}, additional_fields={}): - element = {'type': type, - 'name': name, - 'source_mapping': source_mapping} - if type_specific_fields: - element['type_specific_fields'] = type_specific_fields - if additional_fields: - element['additional_fields'] = additional_fields - return element - - def _create_parent_element(self, element): - from slither.core.children.child_contract import ChildContract - from slither.core.children.child_function import ChildFunction - from slither.core.children.child_inheritance import ChildInheritance - if isinstance(element, ChildInheritance): - if element.contract_declarer: - contract = {'elements': []} - self.add_contract_to_json(element.contract_declarer, contract) - return contract['elements'][0] - elif isinstance(element, ChildContract): - if element.contract: - contract = {'elements': []} - self.add_contract_to_json(element.contract, contract) - return contract['elements'][0] - elif isinstance(element, ChildFunction): - if element.function: - function = {'elements': []} - self.add_function_to_json(element.function, function) - return function['elements'][0] - return None - - def add_variable_to_json(self, variable, d, additional_fields={}): - type_specific_fields = { - 'parent': self._create_parent_element(variable) - } - element = self._create_base_element('variable', - variable.name, - variable.source_mapping, - type_specific_fields, - additional_fields) - d['elements'].append(element) - - def add_variables_to_json(self, variables, d): - for variable in sorted(variables, key=lambda x:x.name): - self.add_variable_to_json(variable, d) - - def add_contract_to_json(self, contract, d, additional_fields={}): - element = self._create_base_element('contract', - contract.name, - contract.source_mapping, - {}, - additional_fields) - d['elements'].append(element) - - def add_function_to_json(self, function, d, additional_fields={}): - type_specific_fields = { - 'parent': self._create_parent_element(function), - 'signature': function.full_name - } - element = self._create_base_element('function', - function.name, - function.source_mapping, - type_specific_fields, - additional_fields) - d['elements'].append(element) - - def add_functions_to_json(self, functions, d, additional_fields={}): - for function in sorted(functions, key=lambda x: x.name): - self.add_function_to_json(function, d, additional_fields) - - def add_enum_to_json(self, enum, d, additional_fields={}): - type_specific_fields = { - 'parent': self._create_parent_element(enum) - } - element = self._create_base_element('enum', - enum.name, - enum.source_mapping, - type_specific_fields, - additional_fields) - d['elements'].append(element) - - def add_struct_to_json(self, struct, d, additional_fields={}): - type_specific_fields = { - 'parent': self._create_parent_element(struct) - } - element = self._create_base_element('struct', - struct.name, - struct.source_mapping, - type_specific_fields, - additional_fields) - d['elements'].append(element) - - def add_event_to_json(self, event, d, additional_fields={}): - type_specific_fields = { - 'parent': self._create_parent_element(event), - 'signature': event.full_name - } - element = self._create_base_element('event', - event.name, - event.source_mapping, - type_specific_fields, - additional_fields) - - d['elements'].append(element) - - def add_node_to_json(self, node, d, additional_fields={}): - type_specific_fields = { - 'parent': self._create_parent_element(node), - } - node_name = str(node.expression) if node.expression else "" - element = self._create_base_element('node', - node_name, - node.source_mapping, - type_specific_fields, - additional_fields) - d['elements'].append(element) - - def add_nodes_to_json(self, nodes, d): - for node in sorted(nodes, key=lambda x: x.node_id): - self.add_node_to_json(node, d) - - def add_pragma_to_json(self, pragma, d, additional_fields={}): - type_specific_fields = { - 'directive': pragma.directive - } - element = self._create_base_element('pragma', - pragma.version, - pragma.source_mapping, - type_specific_fields, - additional_fields) - d['elements'].append(element) - - def add_other_to_json(self, name, source_mapping, d, additional_fields={}): - # If this a tuple with (filename, start, end), convert it to a source mapping. - if isinstance(source_mapping, tuple): - # Parse the source id - (filename, start, end) = source_mapping - source_id = next((source_unit_id for (source_unit_id, source_unit_filename) in self.slither.source_units.items() if source_unit_filename == filename), -1) - - # Convert to a source mapping string - source_mapping = f"{start}:{end}:{source_id}" - - # If this is a source mapping string, parse it. - if isinstance(source_mapping, str): - source_mapping_str = source_mapping - source_mapping = SourceMapping() - source_mapping.set_offset(source_mapping_str, self.slither) - - # If this is a source mapping object, get the underlying source mapping dictionary - if isinstance(source_mapping, SourceMapping): - source_mapping = source_mapping.source_mapping - - # Create the underlying element and add it to our resulting json - element = self._create_base_element('other', - name, - source_mapping, - {}, - additional_fields) - d['elements'].append(element) + return d @staticmethod def _format(slither, result): diff --git a/slither/detectors/attributes/const_functions.py b/slither/detectors/attributes/const_functions.py index 88598392f..438d19b39 100644 --- a/slither/detectors/attributes/const_functions.py +++ b/slither/detectors/attributes/const_functions.py @@ -4,6 +4,8 @@ Recursively check the called functions """ from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification from slither.formatters.attributes.const_functions import format +from slither.utils import json_utils + class ConstantFunctions(AbstractDetector): """ @@ -59,7 +61,7 @@ All the calls to `get` revert, breaking Bob's smart contract execution.''' info = '{} ({}) is declared {} but contains assembly code\n' info = info.format(f.canonical_name, f.source_mapping_str, attr) json = self.generate_json_result(info, {'contains_assembly': True}) - self.add_function_to_json(f, json) + json_utils.add_function_to_json(f, json) results.append(json) variables_written = f.all_state_variables_written() @@ -71,8 +73,8 @@ All the calls to `get` revert, breaking Bob's smart contract execution.''' info += '\t- {}\n'.format(variable_written.canonical_name) json = self.generate_json_result(info, {'contains_assembly': False}) - self.add_function_to_json(f, json) - self.add_variables_to_json(variables_written, json) + json_utils.add_function_to_json(f, json) + json_utils.add_variables_to_json(variables_written, json) results.append(json) return results diff --git a/slither/detectors/attributes/constant_pragma.py b/slither/detectors/attributes/constant_pragma.py index 0c2e54bca..0af8c8ccb 100644 --- a/slither/detectors/attributes/constant_pragma.py +++ b/slither/detectors/attributes/constant_pragma.py @@ -4,6 +4,7 @@ from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification from slither.formatters.attributes.constant_pragma import format +from slither.utils import json_utils class ConstantPragma(AbstractDetector): @@ -39,7 +40,7 @@ class ConstantPragma(AbstractDetector): # Add each pragma to our elements for p in pragma: - self.add_pragma_to_json(p, json) + json_utils.add_pragma_to_json(p, json) results.append(json) return results diff --git a/slither/detectors/attributes/incorrect_solc.py b/slither/detectors/attributes/incorrect_solc.py index 54991722f..040d90dfe 100644 --- a/slither/detectors/attributes/incorrect_solc.py +++ b/slither/detectors/attributes/incorrect_solc.py @@ -12,6 +12,8 @@ from slither.formatters.attributes.incorrect_solc import format # 2: version number # 3: version number # 4: version number +from slither.utils import json_utils + PATTERN = re.compile('(\^|>|>=|<|<=)?([ ]+)?(\d+)\.(\d+)\.(\d+)') class IncorrectSolc(AbstractDetector): @@ -102,7 +104,7 @@ Use Solidity 0.4.25 or 0.5.3. Consider using the latest version of Solidity for info = f"Pragma version \"{p.version}\" {reason} ({p.source_mapping_str})\n" json = self.generate_json_result(info) - self.add_pragma_to_json(p, json) + json_utils.add_pragma_to_json(p, json) results.append(json) return results diff --git a/slither/detectors/attributes/locked_ether.py b/slither/detectors/attributes/locked_ether.py index 2a4e1d1c3..c24a8ee09 100644 --- a/slither/detectors/attributes/locked_ether.py +++ b/slither/detectors/attributes/locked_ether.py @@ -6,6 +6,7 @@ from slither.detectors.abstract_detector import (AbstractDetector, DetectorClassification) from slither.slithir.operations import (HighLevelCall, LowLevelCall, Send, Transfer, NewContract, LibraryCall, InternalCall) +from slither.utils import json_utils class LockedEther(AbstractDetector): @@ -84,8 +85,8 @@ Every ether sent to `Locked` will be lost.''' [f.name for f in funcs_payable]) json = self.generate_json_result(info) - self.add_contract_to_json(contract, json) - self.add_functions_to_json(funcs_payable, json) + json_utils.add_contract_to_json(contract, json) + json_utils.add_functions_to_json(funcs_payable, json) results.append(json) return results diff --git a/slither/detectors/erc/incorrect_erc20_interface.py b/slither/detectors/erc/incorrect_erc20_interface.py index c2c0a4112..79fb73415 100644 --- a/slither/detectors/erc/incorrect_erc20_interface.py +++ b/slither/detectors/erc/incorrect_erc20_interface.py @@ -3,6 +3,7 @@ Detect incorrect erc20 interface. Some contracts do not return a bool on transfer/transferFrom/approve, which may lead to preventing the contract to be used with contracts compiled with recent solc (>0.4.22) """ from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification +from slither.utils import json_utils class IncorrectERC20InterfaceDetection(AbstractDetector): @@ -92,7 +93,7 @@ contract Token{ function.full_name, function.source_mapping_str) json = self.generate_json_result(info) - self.add_function_to_json(function, json) + json_utils.add_function_to_json(function, json) results.append(json) return results diff --git a/slither/detectors/erc/incorrect_erc721_interface.py b/slither/detectors/erc/incorrect_erc721_interface.py index bff88413c..e813bff73 100644 --- a/slither/detectors/erc/incorrect_erc721_interface.py +++ b/slither/detectors/erc/incorrect_erc721_interface.py @@ -2,6 +2,7 @@ Detect incorrect erc721 interface. """ from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification +from slither.utils import json_utils class IncorrectERC721InterfaceDetection(AbstractDetector): @@ -91,7 +92,7 @@ contract Token{ function.full_name, function.source_mapping_str) json = self.generate_json_result(info) - self.add_function_to_json(function, json) + json_utils.add_function_to_json(function, json) results.append(json) return results diff --git a/slither/detectors/erc/unindexed_event_parameters.py b/slither/detectors/erc/unindexed_event_parameters.py index 55ab15e25..73887e0cb 100644 --- a/slither/detectors/erc/unindexed_event_parameters.py +++ b/slither/detectors/erc/unindexed_event_parameters.py @@ -2,6 +2,7 @@ Detect mistakenly un-indexed ERC20 event parameters """ from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification +from slither.utils import json_utils class UnindexedERC20EventParameters(AbstractDetector): @@ -75,7 +76,7 @@ In this case, Transfer and Approval events should have the 'indexed' keyword on # Add the events to the JSON (note: we do not add the params/vars as they have no source mapping). json = self.generate_json_result(info) - self.add_event_to_json(event, json, { + json_utils.add_event_to_json(event, json, { "parameter_name": parameter.name }) results.append(json) diff --git a/slither/detectors/examples/backdoor.py b/slither/detectors/examples/backdoor.py index bbc60a8b3..e95f31e51 100644 --- a/slither/detectors/examples/backdoor.py +++ b/slither/detectors/examples/backdoor.py @@ -1,4 +1,5 @@ from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification +from slither.utils import json_utils class Backdoor(AbstractDetector): @@ -30,7 +31,7 @@ class Backdoor(AbstractDetector): info = info.format(contract.name, f.name, f.source_mapping_str) # Add the result in result json = self.generate_json_result(info) - self.add_function_to_json(f, json) + json_utils.add_function_to_json(f, json) results.append(json) return results diff --git a/slither/detectors/functions/arbitrary_send.py b/slither/detectors/functions/arbitrary_send.py index d28cd1258..e38ff25eb 100644 --- a/slither/detectors/functions/arbitrary_send.py +++ b/slither/detectors/functions/arbitrary_send.py @@ -17,6 +17,7 @@ from slither.detectors.abstract_detector import (AbstractDetector, DetectorClassification) from slither.slithir.operations import (HighLevelCall, Index, LowLevelCall, Send, SolidityCall, Transfer) +from slither.utils import json_utils class ArbitrarySend(AbstractDetector): @@ -117,8 +118,8 @@ Bob calls `setDestination` and `withdraw`. As a result he withdraws the contract info += '\t- {} ({})\n'.format(node.expression, node.source_mapping_str) json = self.generate_json_result(info) - self.add_function_to_json(func, json) - self.add_nodes_to_json(nodes, json) + json_utils.add_function_to_json(func, json) + json_utils.add_nodes_to_json(nodes, json) results.append(json) return results diff --git a/slither/detectors/functions/complex_function.py b/slither/detectors/functions/complex_function.py index fae9a0923..d3668f216 100644 --- a/slither/detectors/functions/complex_function.py +++ b/slither/detectors/functions/complex_function.py @@ -5,6 +5,7 @@ from slither.detectors.abstract_detector import (AbstractDetector, from slither.slithir.operations import (HighLevelCall, LowLevelCall, LibraryCall) +from slither.utils import json_utils from slither.utils.code_complexity import compute_cyclomatic_complexity @@ -105,7 +106,7 @@ class ComplexFunction(AbstractDetector): self.log(info) json = self.generate_json_result(info) - self.add_function_to_json(func, json, { + json_utils.add_function_to_json(func, json, { 'high_number_of_external_calls': cause == self.CAUSE_EXTERNAL_CALL, 'high_number_of_branches': cause == self.CAUSE_CYCLOMATIC, 'high_number_of_state_variables': cause == self.CAUSE_STATE_VARS diff --git a/slither/detectors/functions/external_function.py b/slither/detectors/functions/external_function.py index 233f24f48..3cc828418 100644 --- a/slither/detectors/functions/external_function.py +++ b/slither/detectors/functions/external_function.py @@ -3,6 +3,7 @@ from slither.detectors.abstract_detector import (AbstractDetector, from slither.slithir.operations import SolidityCall from slither.slithir.operations import (InternalCall, InternalDynamicCall) from slither.formatters.functions.external_function import format +from slither.utils import json_utils class ExternalFunction(AbstractDetector): @@ -189,9 +190,9 @@ class ExternalFunction(AbstractDetector): txt += f" ({other_function_definition.source_mapping_str})\n" json = self.generate_json_result(txt) - self.add_function_to_json(function_definition, json) + json_utils.add_function_to_json(function_definition, json) for other_function_definition in all_function_definitions: - self.add_function_to_json(other_function_definition, json) + json_utils.add_function_to_json(other_function_definition, json) results.append(json) return results diff --git a/slither/detectors/functions/suicidal.py b/slither/detectors/functions/suicidal.py index fef1c1224..443c2bd61 100644 --- a/slither/detectors/functions/suicidal.py +++ b/slither/detectors/functions/suicidal.py @@ -5,6 +5,8 @@ A suicidal contract is an unprotected function that calls selfdestruct """ from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification +from slither.utils import json_utils + class Suicidal(AbstractDetector): """ @@ -77,7 +79,7 @@ Bob calls `kill` and destructs the contract.''' func.source_mapping_str) json = self.generate_json_result(info) - self.add_function_to_json(func, json) + json_utils.add_function_to_json(func, json) results.append(json) return results diff --git a/slither/detectors/naming_convention/naming_convention.py b/slither/detectors/naming_convention/naming_convention.py index 3b20a148e..b012441b3 100644 --- a/slither/detectors/naming_convention/naming_convention.py +++ b/slither/detectors/naming_convention/naming_convention.py @@ -1,7 +1,7 @@ import re from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification from slither.formatters.naming_convention.naming_convention import format - +from slither.utils import json_utils class NamingConvention(AbstractDetector): @@ -64,7 +64,7 @@ Solidity defines a [naming convention](https://solidity.readthedocs.io/en/v0.4.2 contract.source_mapping_str) json = self.generate_json_result(info) - self.add_contract_to_json(contract, json, { + json_utils.add_contract_to_json(contract, json, { "target": "contract", "convention": "CapWords" }) @@ -76,7 +76,7 @@ Solidity defines a [naming convention](https://solidity.readthedocs.io/en/v0.4.2 info = info.format(struct.canonical_name, struct.source_mapping_str) json = self.generate_json_result(info) - self.add_struct_to_json(struct, json, { + json_utils.add_struct_to_json(struct, json, { "target": "structure", "convention": "CapWords" }) @@ -88,7 +88,7 @@ Solidity defines a [naming convention](https://solidity.readthedocs.io/en/v0.4.2 info = info.format(event.canonical_name, event.source_mapping_str) json = self.generate_json_result(info) - self.add_event_to_json(event, json, { + json_utils.add_event_to_json(event, json, { "target": "event", "convention": "CapWords" }) @@ -106,7 +106,7 @@ Solidity defines a [naming convention](https://solidity.readthedocs.io/en/v0.4.2 info = info.format(func.canonical_name, func.source_mapping_str) json = self.generate_json_result(info) - self.add_function_to_json(func, json, { + json_utils.add_function_to_json(func, json, { "target": "function", "convention": "mixedCase" }) @@ -127,7 +127,7 @@ Solidity defines a [naming convention](https://solidity.readthedocs.io/en/v0.4.2 argument.source_mapping_str) json = self.generate_json_result(info) - self.add_variable_to_json(argument, json, { + json_utils.add_variable_to_json(argument, json, { "target": "parameter", "convention": "mixedCase" }) @@ -140,7 +140,7 @@ Solidity defines a [naming convention](https://solidity.readthedocs.io/en/v0.4.2 info = info.format(var.canonical_name, var.source_mapping_str) json = self.generate_json_result(info) - self.add_variable_to_json(var, json, { + json_utils.add_variable_to_json(var, json, { "target": "variable", "convention": "l_O_I_should_not_be_used" }) @@ -156,7 +156,7 @@ Solidity defines a [naming convention](https://solidity.readthedocs.io/en/v0.4.2 info = info.format(var.canonical_name, var.source_mapping_str) json = self.generate_json_result(info) - self.add_variable_to_json(var, json, { + json_utils.add_variable_to_json(var, json, { "target": "variable_constant", "convention": "UPPER_CASE_WITH_UNDERSCORES" }) @@ -172,7 +172,7 @@ Solidity defines a [naming convention](https://solidity.readthedocs.io/en/v0.4.2 info = info.format(var.canonical_name, var.source_mapping_str) json = self.generate_json_result(info) - self.add_variable_to_json(var, json, { + json_utils.add_variable_to_json(var, json, { "target": "variable", "convention": "mixedCase" }) @@ -184,7 +184,7 @@ Solidity defines a [naming convention](https://solidity.readthedocs.io/en/v0.4.2 info = info.format(enum.canonical_name, enum.source_mapping_str) json = self.generate_json_result(info) - self.add_enum_to_json(enum, json, { + json_utils.add_enum_to_json(enum, json, { "target": "enum", "convention": "CapWords" }) @@ -197,7 +197,7 @@ Solidity defines a [naming convention](https://solidity.readthedocs.io/en/v0.4.2 modifier.source_mapping_str) json = self.generate_json_result(info) - self.add_function_to_json(modifier, json, { + json_utils.add_function_to_json(modifier, json, { "target": "modifier", "convention": "mixedCase" }) diff --git a/slither/detectors/operations/block_timestamp.py b/slither/detectors/operations/block_timestamp.py index 81c115341..f771c9a9d 100644 --- a/slither/detectors/operations/block_timestamp.py +++ b/slither/detectors/operations/block_timestamp.py @@ -9,6 +9,7 @@ from slither.core.declarations.solidity_variables import (SolidityFunction, from slither.detectors.abstract_detector import (AbstractDetector, DetectorClassification) from slither.slithir.operations import Binary, BinaryType +from slither.utils import json_utils class Timestamp(AbstractDetector): @@ -77,8 +78,8 @@ class Timestamp(AbstractDetector): info += '\t- {} ({})\n'.format(node.expression, node.source_mapping_str) json = self.generate_json_result(info) - self.add_function_to_json(func, json) - self.add_nodes_to_json(nodes, json) + json_utils.add_function_to_json(func, json) + json_utils.add_nodes_to_json(nodes, json) results.append(json) return results diff --git a/slither/detectors/operations/low_level_calls.py b/slither/detectors/operations/low_level_calls.py index 4e36448a4..66ed88a6e 100644 --- a/slither/detectors/operations/low_level_calls.py +++ b/slither/detectors/operations/low_level_calls.py @@ -4,6 +4,7 @@ Module detecting usage of low level calls from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification from slither.slithir.operations import LowLevelCall +from slither.utils import json_utils class LowLevelCalls(AbstractDetector): @@ -54,8 +55,8 @@ class LowLevelCalls(AbstractDetector): info += "\t-{} {}\n".format(str(node.expression), node.source_mapping_str) json = self.generate_json_result(info) - self.add_function_to_json(func, json) - self.add_nodes_to_json(nodes, json) + json_utils.add_function_to_json(func, json) + json_utils.add_nodes_to_json(nodes, json) results.append(json) return results diff --git a/slither/detectors/operations/unused_return_values.py b/slither/detectors/operations/unused_return_values.py index 532b9a72e..1355eeca4 100644 --- a/slither/detectors/operations/unused_return_values.py +++ b/slither/detectors/operations/unused_return_values.py @@ -5,6 +5,8 @@ Module detecting unused return values from external calls from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification from slither.slithir.operations import HighLevelCall, InternalCall, InternalDynamicCall from slither.core.variables.state_variable import StateVariable +from slither.utils import json_utils + class UnusedReturnValues(AbstractDetector): """ @@ -81,8 +83,8 @@ contract MyConc{ node.source_mapping_str) json = self.generate_json_result(info) - self.add_node_to_json(node, json) - self.add_function_to_json(f, json) + json_utils.add_node_to_json(node, json) + json_utils.add_function_to_json(f, json) results.append(json) return results diff --git a/slither/detectors/operations/void_constructor.py b/slither/detectors/operations/void_constructor.py index 756f88538..9a1e8833c 100644 --- a/slither/detectors/operations/void_constructor.py +++ b/slither/detectors/operations/void_constructor.py @@ -1,6 +1,8 @@ from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification from slither.slithir.operations import Nop +from slither.utils import json_utils + class VoidConstructor(AbstractDetector): @@ -40,7 +42,7 @@ By reading B's constructor definition, the reader might assume that `A()` initia info += "\t-{} {}\n".format(str(node.expression), node.source_mapping_str) json = self.generate_json_result(info) - self.add_function_to_json(cst, json) - self.add_nodes_to_json([node], json) + json_utils.add_function_to_json(cst, json) + json_utils.add_nodes_to_json([node], json) results.append(json) return results diff --git a/slither/detectors/reentrancy/reentrancy_benign.py b/slither/detectors/reentrancy/reentrancy_benign.py index 85daabb5d..52df78ff2 100644 --- a/slither/detectors/reentrancy/reentrancy_benign.py +++ b/slither/detectors/reentrancy/reentrancy_benign.py @@ -9,6 +9,7 @@ from slither.core.cfg.node import NodeType from slither.core.declarations import Function, SolidityFunction from slither.core.expressions import UnaryOperation, UnaryOperationType from slither.detectors.abstract_detector import DetectorClassification +from slither.utils import json_utils from slither.visitors.expression.export_values import ExportValues from slither.slithir.operations import (HighLevelCall, LowLevelCall, LibraryCall, @@ -101,11 +102,11 @@ Only report reentrancy that acts as a double call (see `reentrancy-eth`, `reentr json = self.generate_json_result(info) # Add the function with the re-entrancy first - self.add_function_to_json(func, json) + json_utils.add_function_to_json(func, json) # Add all underlying calls in the function which are potentially problematic. for call_info in calls: - self.add_node_to_json(call_info, json, { + json_utils.add_node_to_json(call_info, json, { "underlying_type": "external_calls" }) @@ -114,13 +115,13 @@ Only report reentrancy that acts as a double call (see `reentrancy-eth`, `reentr # If the calls are not the same ones that send eth, add the eth sending nodes. if calls != send_eth: for call_info in send_eth: - self.add_node_to_json(call_info, json, { + json_utils.add_node_to_json(call_info, json, { "underlying_type": "external_calls_sending_eth" }) # Add all variables written via nodes which write them. for (v, node) in varsWritten: - self.add_node_to_json(node, json, { + json_utils.add_node_to_json(node, json, { "underlying_type": "variables_written", "variable_name": v.name }) diff --git a/slither/detectors/reentrancy/reentrancy_eth.py b/slither/detectors/reentrancy/reentrancy_eth.py index 05a0c7a5a..ac838deee 100644 --- a/slither/detectors/reentrancy/reentrancy_eth.py +++ b/slither/detectors/reentrancy/reentrancy_eth.py @@ -11,7 +11,7 @@ from slither.detectors.abstract_detector import DetectorClassification from slither.slithir.operations import (HighLevelCall, LowLevelCall, LibraryCall, Send, Transfer) - +from slither.utils import json_utils from .reentrancy import Reentrancy class ReentrancyEth(Reentrancy): @@ -104,11 +104,11 @@ Bob uses the re-entrancy bug to call `withdrawBalance` two times, and withdraw m json = self.generate_json_result(info) # Add the function with the re-entrancy first - self.add_function_to_json(func, json) + json_utils.add_function_to_json(func, json) # Add all underlying calls in the function which are potentially problematic. for call_info in calls: - self.add_node_to_json(call_info, json, { + json_utils.add_node_to_json(call_info, json, { "underlying_type": "external_calls" }) @@ -117,13 +117,13 @@ Bob uses the re-entrancy bug to call `withdrawBalance` two times, and withdraw m # If the calls are not the same ones that send eth, add the eth sending nodes. if calls != send_eth: for call_info in send_eth: - self.add_node_to_json(call_info, json, { + json_utils.add_node_to_json(call_info, json, { "underlying_type": "external_calls_sending_eth" }) # Add all variables written via nodes which write them. for (v, node) in varsWritten: - self.add_node_to_json(node, json, { + json_utils.add_node_to_json(node, json, { "underlying_type": "variables_written", "variable_name": v.name }) diff --git a/slither/detectors/reentrancy/reentrancy_read_before_write.py b/slither/detectors/reentrancy/reentrancy_read_before_write.py index dfb8aa9cd..0d670ad32 100644 --- a/slither/detectors/reentrancy/reentrancy_read_before_write.py +++ b/slither/detectors/reentrancy/reentrancy_read_before_write.py @@ -9,6 +9,7 @@ from slither.core.cfg.node import NodeType from slither.core.declarations import Function, SolidityFunction from slither.core.expressions import UnaryOperation, UnaryOperationType from slither.detectors.abstract_detector import DetectorClassification +from slither.utils import json_utils from slither.visitors.expression.export_values import ExportValues from slither.slithir.operations import (HighLevelCall, LowLevelCall, LibraryCall, @@ -95,17 +96,17 @@ Do not report reentrancies that involve ethers (see `reentrancy-eth`)''' json = self.generate_json_result(info) # Add the function with the re-entrancy first - self.add_function_to_json(func, json) + json_utils.add_function_to_json(func, json) # Add all underlying calls in the function which are potentially problematic. for call_info in calls: - self.add_node_to_json(call_info, json, { + json_utils.add_node_to_json(call_info, json, { "underlying_type": "external_calls" }) # Add all variables written via nodes which write them. for (v, node) in varsWritten: - self.add_node_to_json(node, json, { + json_utils.add_node_to_json(node, json, { "underlying_type": "variables_written", "variable_name": v.name }) diff --git a/slither/detectors/shadowing/abstract.py b/slither/detectors/shadowing/abstract.py index 15bb7e2c1..5cdb3327e 100644 --- a/slither/detectors/shadowing/abstract.py +++ b/slither/detectors/shadowing/abstract.py @@ -4,6 +4,7 @@ Recursively check the called functions """ from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification +from slither.utils import json_utils class ShadowingAbstractDetection(AbstractDetector): @@ -72,7 +73,7 @@ contract DerivedContract is BaseContract{ var.source_mapping_str) json = self.generate_json_result(info) - self.add_variables_to_json(all_variables, json) + json_utils.add_variables_to_json(all_variables, json) results.append(json) return results diff --git a/slither/detectors/shadowing/builtin_symbols.py b/slither/detectors/shadowing/builtin_symbols.py index 2cd4cff09..e1f7ee6fb 100644 --- a/slither/detectors/shadowing/builtin_symbols.py +++ b/slither/detectors/shadowing/builtin_symbols.py @@ -3,6 +3,7 @@ Module detecting reserved keyword shadowing """ from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification +from slither.utils import json_utils class BuiltinSymbolShadowing(AbstractDetector): @@ -140,11 +141,11 @@ contract Bug { # Generate relevant JSON data for this shadowing definition. json = self.generate_json_result(info) if shadow_type in [self.SHADOWING_FUNCTION, self.SHADOWING_MODIFIER]: - self.add_function_to_json(shadow_object, json) + json_utils.add_function_to_json(shadow_object, json) elif shadow_type == self.SHADOWING_EVENT: - self.add_event_to_json(shadow_object, json) + json_utils.add_event_to_json(shadow_object, json) elif shadow_type in [self.SHADOWING_STATE_VARIABLE, self.SHADOWING_LOCAL_VARIABLE]: - self.add_variable_to_json(shadow_object, json) + json_utils.add_variable_to_json(shadow_object, json) results.append(json) return results diff --git a/slither/detectors/shadowing/local.py b/slither/detectors/shadowing/local.py index 66f769882..63c3c592c 100644 --- a/slither/detectors/shadowing/local.py +++ b/slither/detectors/shadowing/local.py @@ -3,6 +3,7 @@ Module detecting local variable shadowing """ from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification +from slither.utils import json_utils class LocalShadowing(AbstractDetector): @@ -117,14 +118,14 @@ contract Bug { # Generate relevant JSON data for this shadowing definition. json = self.generate_json_result(info) - self.add_variable_to_json(local_variable, json) + json_utils.add_variable_to_json(local_variable, json) for overshadowed_entry in overshadowed: if overshadowed_entry[0] in [self.OVERSHADOWED_FUNCTION, self.OVERSHADOWED_MODIFIER]: - self.add_function_to_json(overshadowed_entry[2], json) + json_utils.add_function_to_json(overshadowed_entry[2], json) elif overshadowed_entry[0] == self.OVERSHADOWED_EVENT: - self.add_event_to_json(overshadowed_entry[2], json) + json_utils.add_event_to_json(overshadowed_entry[2], json) elif overshadowed_entry[0] == self.OVERSHADOWED_STATE_VARIABLE: - self.add_variable_to_json(overshadowed_entry[2], json) + json_utils.add_variable_to_json(overshadowed_entry[2], json) results.append(json) return results diff --git a/slither/detectors/shadowing/state.py b/slither/detectors/shadowing/state.py index 41da711f3..2ef792b55 100644 --- a/slither/detectors/shadowing/state.py +++ b/slither/detectors/shadowing/state.py @@ -3,6 +3,7 @@ Module detecting shadowing of state variables """ from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification +from slither.utils import json_utils class StateShadowing(AbstractDetector): @@ -83,7 +84,7 @@ contract DerivedContract is BaseContract{ var.source_mapping_str) json = self.generate_json_result(info) - self.add_variables_to_json(all_variables, json) + json_utils.add_variables_to_json(all_variables, json) results.append(json) diff --git a/slither/detectors/source/rtlo.py b/slither/detectors/source/rtlo.py index 5c0599940..a3b34253d 100644 --- a/slither/detectors/source/rtlo.py +++ b/slither/detectors/source/rtlo.py @@ -1,6 +1,9 @@ from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification import re +from slither.utils import json_utils + + class RightToLeftOverride(AbstractDetector): """ Detect the usage of a Right-To-Left-Override (U+202E) character @@ -72,8 +75,10 @@ contract Token info += f"\t- {pattern.findall(source_encoded)[0]}\n" json = self.generate_json_result(info) - self.add_other_to_json("rtlo-character", - (filename, idx, len(self.RTLO_CHARACTER_ENCODED)), json) + json_utils.add_other_to_json("rtlo-character", + (filename, idx, len(self.RTLO_CHARACTER_ENCODED)), + json, + self.slither) results.append(json) # Advance the start index for the next iteration diff --git a/slither/detectors/statements/assembly.py b/slither/detectors/statements/assembly.py index 936794366..5fecabbaf 100644 --- a/slither/detectors/statements/assembly.py +++ b/slither/detectors/statements/assembly.py @@ -4,6 +4,7 @@ Module detecting usage of inline assembly from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification from slither.core.cfg.node import NodeType +from slither.utils import json_utils class Assembly(AbstractDetector): @@ -58,8 +59,8 @@ class Assembly(AbstractDetector): info += "\t- {}\n".format(node.source_mapping_str) json = self.generate_json_result(info) - self.add_function_to_json(func, json) - self.add_nodes_to_json(nodes, json) + json_utils.add_function_to_json(func, json) + json_utils.add_nodes_to_json(nodes, json) results.append(json) return results diff --git a/slither/detectors/statements/calls_in_loop.py b/slither/detectors/statements/calls_in_loop.py index 092003c8f..1b0dd2a75 100644 --- a/slither/detectors/statements/calls_in_loop.py +++ b/slither/detectors/statements/calls_in_loop.py @@ -5,6 +5,7 @@ from slither.detectors.abstract_detector import (AbstractDetector, DetectorClassification) from slither.slithir.operations import (HighLevelCall, LibraryCall, LowLevelCall, Send, Transfer) +from slither.utils import json_utils class MultipleCallsInLoop(AbstractDetector): @@ -91,7 +92,7 @@ If one of the destinations has a fallback function which reverts, `bad` will alw info = info.format(func.canonical_name, node.expression, node.source_mapping_str) json = self.generate_json_result(info) - self.add_node_to_json(node, json) + json_utils.add_node_to_json(node, json) results.append(json) return results diff --git a/slither/detectors/statements/controlled_delegatecall.py b/slither/detectors/statements/controlled_delegatecall.py index e84277009..c07c2628f 100644 --- a/slither/detectors/statements/controlled_delegatecall.py +++ b/slither/detectors/statements/controlled_delegatecall.py @@ -1,6 +1,8 @@ from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification from slither.slithir.operations import LowLevelCall from slither.analyses.data_dependency.data_dependency import is_tainted +from slither.utils import json_utils + class ControlledDelegateCall(AbstractDetector): """ @@ -52,8 +54,8 @@ Bob calls `delegate` and delegates the execution to its malicious contract. As a node_info = func_info + '\t- {} ({})\n'.format(node.expression, node.source_mapping_str) json = self.generate_json_result(node_info) - self.add_node_to_json(node, json) - self.add_function_to_json(f, json) + json_utils.add_node_to_json(node, json) + json_utils.add_function_to_json(f, json) results.append(json) return results diff --git a/slither/detectors/statements/deprecated_calls.py b/slither/detectors/statements/deprecated_calls.py index c18843125..12cccd579 100644 --- a/slither/detectors/statements/deprecated_calls.py +++ b/slither/detectors/statements/deprecated_calls.py @@ -3,6 +3,7 @@ Module detecting deprecated standards. """ from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification +from slither.utils import json_utils from slither.visitors.expression.export_values import ExportValues from slither.core.declarations.solidity_variables import SolidityVariableComposed, SolidityFunction from slither.core.cfg.node import NodeType @@ -162,9 +163,9 @@ contract ContractWithDeprecatedReferences { # Generate relevant JSON data for this deprecated standard. json = self.generate_json_result(info) if isinstance(source_object, StateVariableSolc) or isinstance(source_object, StateVariable): - self.add_variable_to_json(source_object, json) + json_utils.add_variable_to_json(source_object, json) else: - self.add_nodes_to_json([source_object], json) + json_utils.add_nodes_to_json([source_object], json) results.append(json) diff --git a/slither/detectors/statements/incorrect_strict_equality.py b/slither/detectors/statements/incorrect_strict_equality.py index fe5da8cbf..ac2d39283 100644 --- a/slither/detectors/statements/incorrect_strict_equality.py +++ b/slither/detectors/statements/incorrect_strict_equality.py @@ -16,6 +16,8 @@ from slither.core.solidity_types import MappingType, ElementaryType from slither.core.variables.state_variable import StateVariable from slither.core.declarations.solidity_variables import SolidityVariable, SolidityVariableComposed from slither.slithir.variables import ReferenceVariable +from slither.utils import json_utils + class IncorrectStrictEquality(AbstractDetector): ARGUMENT = 'incorrect-equality' @@ -123,8 +125,8 @@ contract Crowdsale{ node_info = func_info + f"\t- {str(node.expression)}\n" json = self.generate_json_result(node_info) - self.add_node_to_json(node, json) - self.add_function_to_json(f, json) + json_utils.add_node_to_json(node, json) + json_utils.add_function_to_json(f, json) results.append(json) return results diff --git a/slither/detectors/statements/too_many_digits.py b/slither/detectors/statements/too_many_digits.py index 6b74fb9f4..29844100d 100644 --- a/slither/detectors/statements/too_many_digits.py +++ b/slither/detectors/statements/too_many_digits.py @@ -4,6 +4,8 @@ Module detecting numbers with too many digits. from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification from slither.slithir.variables import Constant +from slither.utils import json_utils + class TooManyDigits(AbstractDetector): """ @@ -71,7 +73,7 @@ Use: # Add the result in result json = self.generate_json_result(node_info) - self.add_node_to_json(node, json) + json_utils.add_node_to_json(node, json) results.append(json) return results diff --git a/slither/detectors/statements/tx_origin.py b/slither/detectors/statements/tx_origin.py index e759366eb..6d7cd10d5 100644 --- a/slither/detectors/statements/tx_origin.py +++ b/slither/detectors/statements/tx_origin.py @@ -3,6 +3,8 @@ Module detecting usage of `tx.origin` in a conditional node """ from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification +from slither.utils import json_utils + class TxOrigin(AbstractDetector): """ @@ -72,7 +74,7 @@ Bob is the owner of `TxOrigin`. Bob calls Eve's contract. Eve's contract calls ` node.source_mapping_str) json = self.generate_json_result(info) - self.add_node_to_json(node, json) + json_utils.add_node_to_json(node, json) results.append(json) return results diff --git a/slither/detectors/variables/possible_const_state_variables.py b/slither/detectors/variables/possible_const_state_variables.py index e6c676c16..9e4a04cd9 100644 --- a/slither/detectors/variables/possible_const_state_variables.py +++ b/slither/detectors/variables/possible_const_state_variables.py @@ -4,6 +4,7 @@ Module detecting state variables that could be declared as constant from slither.core.solidity_types.elementary_type import ElementaryType from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification +from slither.utils import json_utils from slither.visitors.expression.export_values import ExportValues from slither.core.declarations.solidity_variables import SolidityFunction from slither.core.variables.state_variable import StateVariable @@ -91,7 +92,7 @@ class ConstCandidateStateVars(AbstractDetector): info = "{} should be constant ({})\n".format(v.canonical_name, v.source_mapping_str) json = self.generate_json_result(info) - self.add_variable_to_json(v, json) + json_utils.add_variable_to_json(v, json) results.append(json) diff --git a/slither/detectors/variables/uninitialized_local_variables.py b/slither/detectors/variables/uninitialized_local_variables.py index 39219ae4a..265727234 100644 --- a/slither/detectors/variables/uninitialized_local_variables.py +++ b/slither/detectors/variables/uninitialized_local_variables.py @@ -7,6 +7,7 @@ from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification from slither.core.cfg.node import NodeType +from slither.utils import json_utils from slither.visitors.expression.find_push import FindPush @@ -108,8 +109,8 @@ Bob calls `transfer`. As a result, the ethers are sent to the address 0x0 and ar json = self.generate_json_result(info) - self.add_variable_to_json(uninitialized_local_variable, json) - self.add_function_to_json(function, json) + json_utils.add_variable_to_json(uninitialized_local_variable, json) + json_utils.add_function_to_json(function, json) results.append(json) return results diff --git a/slither/detectors/variables/uninitialized_state_variables.py b/slither/detectors/variables/uninitialized_state_variables.py index 18b89324b..2250d9caf 100644 --- a/slither/detectors/variables/uninitialized_state_variables.py +++ b/slither/detectors/variables/uninitialized_state_variables.py @@ -16,6 +16,7 @@ from slither.slithir.operations.assignment import Assignment from slither.slithir.operations import (OperationWithLValue, Index, Member, InternalCall, InternalDynamicCall, LibraryCall) +from slither.utils import json_utils class UninitializedStateVarsDetection(AbstractDetector): @@ -102,8 +103,8 @@ Initialize all the variables. If a variable is meant to be initialized to zero, source += [f.source_mapping for f in functions] json = self.generate_json_result(info) - self.add_variable_to_json(variable, json) - self.add_functions_to_json(functions, json) + json_utils.add_variable_to_json(variable, json) + json_utils.add_functions_to_json(functions, json) results.append(json) return results diff --git a/slither/detectors/variables/uninitialized_storage_variables.py b/slither/detectors/variables/uninitialized_storage_variables.py index ef1d9ba3c..072300299 100644 --- a/slither/detectors/variables/uninitialized_storage_variables.py +++ b/slither/detectors/variables/uninitialized_storage_variables.py @@ -6,6 +6,7 @@ """ from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification +from slither.utils import json_utils from slither.visitors.expression.find_push import FindPush @@ -110,8 +111,8 @@ Bob calls `func`. As a result, `owner` is override to 0. json = self.generate_json_result(info) - self.add_variable_to_json(uninitialized_storage_variable, json) - self.add_function_to_json(function, json) + json_utils.add_variable_to_json(uninitialized_storage_variable, json) + json_utils.add_function_to_json(function, json) results.append(json) return results diff --git a/slither/detectors/variables/unused_state_variables.py b/slither/detectors/variables/unused_state_variables.py index 7e01652b5..a815710c7 100644 --- a/slither/detectors/variables/unused_state_variables.py +++ b/slither/detectors/variables/unused_state_variables.py @@ -4,6 +4,7 @@ Module detecting unused state variables from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification from slither.core.solidity_types import ArrayType +from slither.utils import json_utils from slither.visitors.expression.export_values import ExportValues from slither.core.variables.state_variable import StateVariable from slither.formatters.variables.unused_state_variables import format @@ -66,8 +67,8 @@ class UnusedStateVars(AbstractDetector): json = self.generate_json_result(info) - self.add_variable_to_json(var, json) - self.add_contract_to_json(c, json) + json_utils.add_variable_to_json(var, json) + json_utils.add_contract_to_json(c, json) results.append(json) return results diff --git a/slither/utils/json_utils.py b/slither/utils/json_utils.py index 7c92054c7..b748a7a09 100644 --- a/slither/utils/json_utils.py +++ b/slither/utils/json_utils.py @@ -1,9 +1,20 @@ import os import json import logging +from collections import OrderedDict + +from slither.core.source_mapping.source_mapping import SourceMapping from slither.utils.colors import yellow + logger = logging.getLogger("Slither") + +################################################################################### +################################################################################### +# region Output +################################################################################### +################################################################################### + def output_json(filename, error, results): """ @@ -34,3 +45,293 @@ def output_json(filename, error, results): else: with open(filename, 'w', encoding='utf8') as f: json.dump(json_result, f, indent=2) + + +# endregion +################################################################################### +################################################################################### +# region Json generation +################################################################################### +################################################################################### + +def generate_json_result(info, additional_fields=None): + if additional_fields is None: + additional_fields = {} + d = OrderedDict() + d['elements'] = [] + d['description'] = info + if additional_fields: + d['additional_fields'] = additional_fields + + return d + + +# endregion +################################################################################### +################################################################################### +# region Internal functions +################################################################################### +################################################################################### + +def _create_base_element(type, name, source_mapping, type_specific_fields=None, additional_fields=None): + if additional_fields is None: + additional_fields = {} + if type_specific_fields is None: + type_specific_fields = {} + element = {'type': type, + 'name': name, + 'source_mapping': source_mapping} + if type_specific_fields: + element['type_specific_fields'] = type_specific_fields + if additional_fields: + element['additional_fields'] = additional_fields + return element + + +def _create_parent_element(element): + from slither.core.children.child_contract import ChildContract + from slither.core.children.child_function import ChildFunction + from slither.core.children.child_inheritance import ChildInheritance + if isinstance(element, ChildInheritance): + if element.contract_declarer: + contract = {'elements': []} + add_contract_to_json(element.contract_declarer, contract) + return contract['elements'][0] + elif isinstance(element, ChildContract): + if element.contract: + contract = {'elements': []} + add_contract_to_json(element.contract, contract) + return contract['elements'][0] + elif isinstance(element, ChildFunction): + if element.function: + function = {'elements': []} + add_function_to_json(element.function, function) + return function['elements'][0] + return None + + +# endregion +################################################################################### +################################################################################### +# region Variables +################################################################################### +################################################################################### + +def add_variable_to_json(variable, d, additional_fields=None): + if additional_fields is None: + additional_fields = {} + type_specific_fields = { + 'parent': _create_parent_element(variable) + } + element = _create_base_element('variable', + variable.name, + variable.source_mapping, + type_specific_fields, + additional_fields) + d['elements'].append(element) + + +def add_variables_to_json(variables, d): + for variable in sorted(variables, key=lambda x: x.name): + add_variable_to_json(variable, d) + + +# endregion +################################################################################### +################################################################################### +# region Contract +################################################################################### +################################################################################### + +def add_contract_to_json(contract, d, additional_fields=None): + if additional_fields is None: + additional_fields = {} + element = _create_base_element('contract', + contract.name, + contract.source_mapping, + {}, + additional_fields) + d['elements'].append(element) + + +# endregion +################################################################################### +################################################################################### +# region Functions +################################################################################### +################################################################################### + +def add_function_to_json(function, d, additional_fields=None): + if additional_fields is None: + additional_fields = {} + type_specific_fields = { + 'parent': _create_parent_element(function), + 'signature': function.full_name + } + element = _create_base_element('function', + function.name, + function.source_mapping, + type_specific_fields, + additional_fields) + d['elements'].append(element) + + +def add_functions_to_json(functions, d, additional_fields=None): + if additional_fields is None: + additional_fields = {} + for function in sorted(functions, key=lambda x: x.name): + add_function_to_json(function, d, additional_fields) + + +# endregion +################################################################################### +################################################################################### +# region Enum +################################################################################### +################################################################################### + + +def add_enum_to_json(enum, d, additional_fields=None): + if additional_fields is None: + additional_fields = {} + type_specific_fields = { + 'parent': _create_parent_element(enum) + } + element = _create_base_element('enum', + enum.name, + enum.source_mapping, + type_specific_fields, + additional_fields) + d['elements'].append(element) + + +# endregion +################################################################################### +################################################################################### +# region Structures +################################################################################### +################################################################################### + +def add_struct_to_json(struct, d, additional_fields=None): + if additional_fields is None: + additional_fields = {} + type_specific_fields = { + 'parent': _create_parent_element(struct) + } + element = _create_base_element('struct', + struct.name, + struct.source_mapping, + type_specific_fields, + additional_fields) + d['elements'].append(element) + + +# endregion +################################################################################### +################################################################################### +# region Events +################################################################################### +################################################################################### + +def add_event_to_json(event, d, additional_fields=None): + if additional_fields is None: + additional_fields = {} + type_specific_fields = { + 'parent': _create_parent_element(event), + 'signature': event.full_name + } + element = _create_base_element('event', + event.name, + event.source_mapping, + type_specific_fields, + additional_fields) + + d['elements'].append(element) + + +# endregion +################################################################################### +################################################################################### +# region Nodes +################################################################################### +################################################################################### + +def add_node_to_json(node, d, additional_fields=None): + if additional_fields is None: + additional_fields = {} + type_specific_fields = { + 'parent': _create_parent_element(node), + } + node_name = str(node.expression) if node.expression else "" + element = _create_base_element('node', + node_name, + node.source_mapping, + type_specific_fields, + additional_fields) + d['elements'].append(element) + + +def add_nodes_to_json(nodes, d): + for node in sorted(nodes, key=lambda x: x.node_id): + add_node_to_json(node, d) + + +# endregion +################################################################################### +################################################################################### +# region Pragma +################################################################################### +################################################################################### + +def add_pragma_to_json(pragma, d, additional_fields=None): + if additional_fields is None: + additional_fields = {} + type_specific_fields = { + 'directive': pragma.directive + } + element = _create_base_element('pragma', + pragma.version, + pragma.source_mapping, + type_specific_fields, + additional_fields) + d['elements'].append(element) + + +# endregion +################################################################################### +################################################################################### +# region Others +################################################################################### +################################################################################### + +def add_other_to_json(name, source_mapping, d, slither, additional_fields=None): + # If this a tuple with (filename, start, end), convert it to a source mapping. + if additional_fields is None: + additional_fields = {} + if isinstance(source_mapping, tuple): + # Parse the source id + (filename, start, end) = source_mapping + source_id = next( + (source_unit_id for (source_unit_id, source_unit_filename) in slither.source_units.items() if + source_unit_filename == filename), -1) + + # Convert to a source mapping string + source_mapping = f"{start}:{end}:{source_id}" + + # If this is a source mapping string, parse it. + if isinstance(source_mapping, str): + source_mapping_str = source_mapping + source_mapping = SourceMapping() + source_mapping.set_offset(source_mapping_str, slither) + + # If this is a source mapping object, get the underlying source mapping dictionary + if isinstance(source_mapping, SourceMapping): + source_mapping = source_mapping.source_mapping + + # Create the underlying element and add it to our resulting json + element = _create_base_element('other', + name, + source_mapping, + {}, + additional_fields) + d['elements'].append(element) From 3273e0003f98c2226aba3432aa90ee6f98ba842f Mon Sep 17 00:00:00 2001 From: Josselin Date: Sat, 26 Oct 2019 13:33:53 +0200 Subject: [PATCH 204/223] upgradeability: Use json_utils --- .../upgradeability/check_initialization.py | 41 +++++-------- .../check_variable_initialization.py | 12 ++-- .../upgradeability/compare_function_ids.py | 59 +++++++++++++++---- .../upgradeability/compare_variables_order.py | 35 +++++------ .../tools/upgradeability/constant_checks.py | 39 ++++++------ tests/check-upgradeability/test_3.txt | 2 +- 6 files changed, 102 insertions(+), 86 deletions(-) diff --git a/slither/tools/upgradeability/check_initialization.py b/slither/tools/upgradeability/check_initialization.py index 431ef800a..446468389 100644 --- a/slither/tools/upgradeability/check_initialization.py +++ b/slither/tools/upgradeability/check_initialization.py @@ -1,6 +1,7 @@ import logging from slither.slithir.operations import InternalCall +from slither.utils import json_utils from slither.utils.colors import red, yellow, green logger = logging.getLogger("Slither-check-upgradeability") @@ -73,12 +74,9 @@ def check_initialization(contract): initializer_modifier_missing = True info = f'{f.canonical_name} does not call the initializer modifier' logger.info(red(info)) - results['missing-initializer-modifier'].append({ - 'description': info, - 'function': f.full_name, - 'contract': f.contract_declarer.name, - 'source_mapping': f.source_mapping - }) + json_elem = json_utils.generate_json_result(info) + json_utils.add_function_to_json(f, json_elem) + results['missing-initializer-modifier'].append(json_elem) if not initializer_modifier_missing: logger.info(green('All the init functions have the initializer modifier')) @@ -105,15 +103,10 @@ def check_initialization(contract): for f in missing_calls: info = f'Missing call to {f.canonical_name} in {most_derived_init.canonical_name}' logger.info(red(info)) - results['missing-calls'].append({ - 'description': info, - 'function': f.full_name, - 'contract': f.contract_declarer.name, - 'source_mapping': f.source_mapping, - 'most_derived_init': most_derived_init.full_name, - 'most_derived_init_contract': most_derived_init.contract_declarer.name, - 'most_derived_init_source_mapping': most_derived_init.source_mapping, - }) + json_elem = json_utils.generate_json_result(info) + json_utils.add_function_to_json(f, json_elem, {"is_most_derived_init_function": False}) + json_utils.add_function_to_json(most_derived_init, json_elem, {"is_most_derived_init_function": True}) + results['missing-calls'].append(json_elem) missing_call = True if not missing_call: logger.info(green('No missing call to an init function found')) @@ -124,12 +117,9 @@ def check_initialization(contract): for f in double_calls: info = f'{f.canonical_name} is called multiple times in {most_derived_init.full_name}' logger.info(red(info)) - results['multiple-calls'].append({ - 'description': info, - 'function': f.full_name, - 'contract': f.contract_declarer.name, - 'source_mapping': f.source_mapping, - }) + json_elem = json_utils.generate_json_result(info) + json_utils.add_function_to_json(f, json_elem) + results['multiple-calls'].append(json_elem) double_calls_found = True if not double_calls_found: logger.info(green('No double call to init functions found')) @@ -138,12 +128,9 @@ def check_initialization(contract): init_info = f'{contract.name} needs to be initialized by {most_derived_init.full_name}\n' logger.info(green('Check the deployement script to ensure that these functions are called:\n' + init_info)) - results['initialize_target'] = { - 'description': init_info, - 'function': most_derived_init.full_name, - 'contract': most_derived_init.contract_declarer.name, - 'source_mapping': most_derived_init.source_mapping - } + json_elem = json_utils.generate_json_result(init_info) + json_utils.add_function_to_json(most_derived_init, json_elem) + results['initialize_target'] = json_elem if not error_found: logger.info(green('No error found')) diff --git a/slither/tools/upgradeability/check_variable_initialization.py b/slither/tools/upgradeability/check_variable_initialization.py index 7193e86a3..cedfbc314 100644 --- a/slither/tools/upgradeability/check_variable_initialization.py +++ b/slither/tools/upgradeability/check_variable_initialization.py @@ -1,5 +1,6 @@ import logging +from slither.utils import json_utils from slither.utils.colors import red, green logger = logging.getLogger("Slither-check-upgradeability") @@ -19,14 +20,9 @@ def check_variable_initialization(contract): if s.initialized and not s.is_constant: info = f'{s.canonical_name} has an initial value ({s.source_mapping_str})' logger.info(red(info)) - results['variables-initialized'].append( - { - 'description': info, - 'name': s.name, - 'contract': s.contract.name, - 'source_mapping': s.source_mapping - } - ) + json_elem = json_utils.generate_json_result(info) + json_utils.add_variable_to_json(s, json_elem) + results['variables-initialized'].append(json_elem) error_found = True if not error_found: diff --git a/slither/tools/upgradeability/compare_function_ids.py b/slither/tools/upgradeability/compare_function_ids.py index 795627160..da7eda61e 100644 --- a/slither/tools/upgradeability/compare_function_ids.py +++ b/slither/tools/upgradeability/compare_function_ids.py @@ -5,6 +5,9 @@ import logging from slither import Slither +from slither.core.declarations import Function +from slither.exceptions import SlitherError +from slither.utils import json_utils from slither.utils.function import get_function_id from slither.utils.colors import red, green @@ -20,6 +23,20 @@ def get_signatures(c): return list(set(functions+variables)) +def _get_function_or_variable(contract, signature): + f = contract.get_function_from_signature(signature) + + if f: + return f + + for variable in contract.state_variables: + # Todo: can lead to incorrect variable in case of shadowing + if variable.visibility in ['public']: + if variable.name + '()' == signature: + return variable + + raise SlitherError(f'Function id checks: {signature} not found in {contract.name}') + def compare_function_ids(implem, proxy): results = { @@ -40,20 +57,42 @@ def compare_function_ids(implem, proxy): if k in signatures_ids_proxy: error_found = True if signatures_ids_implem[k] != signatures_ids_proxy[k]: - info = 'Function id collision found {} {}'.format(signatures_ids_implem[k], signatures_ids_proxy[k]) + + implem_function = _get_function_or_variable(implem, signatures_ids_implem[k]) + proxy_function = _get_function_or_variable(proxy, signatures_ids_proxy[k]) + + info = f'Function id collision found: {implem_function.canonical_name} ({implem_function.source_mapping_str}) {proxy_function.canonical_name} ({proxy_function.source_mapping_str})' logger.info(red(info)) - results['function-id-collision'].append({ - 'description': info, - 'function1': signatures_ids_implem[k], - 'function2': signatures_ids_proxy[k], - }) + json_elem = json_utils.generate_json_result(info) + if isinstance(implem_function, Function): + json_utils.add_function_to_json(implem_function, json_elem) + else: + json_utils.add_variable_to_json(implem_function, json_elem) + if isinstance(proxy_function, Function): + json_utils.add_function_to_json(proxy_function, json_elem) + else: + json_utils.add_variable_to_json(proxy_function, json_elem) + results['function-id-collision'].append(json_elem) else: - info = 'Shadowing between proxy and implementation found {}'.format(signatures_ids_implem[k]) + + implem_function = _get_function_or_variable(implem, signatures_ids_implem[k]) + proxy_function = _get_function_or_variable(proxy, signatures_ids_proxy[k]) + + info = f'Shadowing between {implem_function.canonical_name} ({implem_function.source_mapping_str}) and {proxy_function.canonical_name} ({proxy_function.source_mapping_str})' logger.info(red(info)) - results['shadowing'].append({ - 'function': signatures_ids_implem[k] - }) + + json_elem = json_utils.generate_json_result(info) + json_elem = json_utils.generate_json_result(info) + if isinstance(implem_function, Function): + json_utils.add_function_to_json(implem_function, json_elem) + else: + json_utils.add_variable_to_json(implem_function, json_elem) + if isinstance(proxy_function, Function): + json_utils.add_function_to_json(proxy_function, json_elem) + else: + json_utils.add_variable_to_json(proxy_function, json_elem) + results['shadowing'].append(json_elem) if not error_found: logger.info(green('No error found')) diff --git a/slither/tools/upgradeability/compare_variables_order.py b/slither/tools/upgradeability/compare_variables_order.py index fe1d5efd1..3b8fd9c30 100644 --- a/slither/tools/upgradeability/compare_variables_order.py +++ b/slither/tools/upgradeability/compare_variables_order.py @@ -2,6 +2,8 @@ Check if the variables respect the same ordering ''' import logging + +from slither.utils import json_utils from slither.utils.colors import red, green, yellow logger = logging.getLogger("Slither-check-upgradeability") @@ -29,11 +31,11 @@ def compare_variables_order(contract1, contract2, missing_variable_check=True): if missing_variable_check: info = f'Variable only in {contract1.name}: {variable1.name} ({variable1.source_mapping_str})' logger.info(yellow(info)) - results['missing_variables'].append({ - 'description': info, - 'variable': variable1.name, - 'source_mapping': variable1.source_mapping - }) + + json_elem = json_utils.generate_json_result(info) + json_utils.add_variable_to_json(variable1, json_elem) + results['missing_variables'].append(json_elem) + error_found = True continue @@ -44,14 +46,12 @@ def compare_variables_order(contract1, contract2, missing_variable_check=True): info += f'\t Variable {idx} in {contract1.name}: {variable1.name} {variable1.type} ({variable1.source_mapping_str})\n' info += f'\t Variable {idx} in {contract2.name}: {variable2.name} {variable2.type} ({variable2.source_mapping_str})\n' logger.info(red(info)) - results['different-variables'].append({ - 'description': info, - 'index': idx, - 'variable1': variable1.name, - 'variable1_source_mapping': variable1.source_mapping, - 'variable2': variable2.name, - 'variable2_source_mapping': variable2.source_mapping, - }) + + json_elem = json_utils.generate_json_result(info, additional_fields={'index': idx}) + json_utils.add_variable_to_json(variable1, json_elem) + json_utils.add_variable_to_json(variable2, json_elem) + results['different-variables'].append(json_elem) + error_found = True idx = idx + 1 @@ -61,12 +61,9 @@ def compare_variables_order(contract1, contract2, missing_variable_check=True): info = f'Extra variables in {contract2.name}: {variable2.name} ({variable2.source_mapping_str})\n' logger.info(yellow(info)) - results['extra-variables'].append({ - 'description': info, - 'index': idx, - 'variable': variable2.name, - 'variable_source_mapping': variable2.source_mapping - }) + json_elem = json_utils.generate_json_result(info, additional_fields={'index': idx}) + json_utils.add_variable_to_json(variable2, json_elem) + results['extra-variables'].append(json_elem) idx = idx + 1 if not error_found: diff --git a/slither/tools/upgradeability/constant_checks.py b/slither/tools/upgradeability/constant_checks.py index 653842f8d..413e95dcf 100644 --- a/slither/tools/upgradeability/constant_checks.py +++ b/slither/tools/upgradeability/constant_checks.py @@ -1,5 +1,6 @@ import logging +from slither.utils import json_utils from slither.utils.colors import red, yellow, green logger = logging.getLogger("Slither-check-upgradeability") @@ -32,36 +33,32 @@ def constant_conformance_check(contract_v1, contract_v2): if not state_v2.is_constant: info = f'{state_v1.canonical_name} ({state_v1.source_mapping_str}) was constant and {state_v2.canonical_name} is not ({state_v2.source_mapping_str})' logger.info(red(info)) - results['were_constants'].append({ - 'description': info, - 'contract_v1': contract_v1.name, - 'contract_v2': contract_v2.name, - 'variable': state_v1.name, - 'source_mapping': state_v1.source_mapping - }) + + json_elem = json_utils.generate_json_result(info) + json_utils.add_variable_to_json(state_v1, json_elem) + json_utils.add_variable_to_json(state_v2, json_elem) + results['were_constants'].append(json_elem) error_found = True + elif state_v2.is_constant: info = f'{state_v1.canonical_name} ({state_v1.source_mapping_str}) was not constant but {state_v2.canonical_name} is ({state_v2.source_mapping_str})' logger.info(red(info)) - results['became_constants'].append({ - 'description': info, - 'contract_v1': contract_v1.name, - 'contract_v2': contract_v2.name, - 'variable': state_v1.name, - 'source_mapping': state_v1.source_mapping - }) + + json_elem = json_utils.generate_json_result(info) + json_utils.add_variable_to_json(state_v1, json_elem) + json_utils.add_variable_to_json(state_v2, json_elem) + results['became_constants'].append(json_elem) error_found = True else: info = f'{state_v1.canonical_name} not found in {contract_v2.name}, not check was done' logger.info(yellow(info)) - results['not_found_in_v2'].append({ - 'description': info, - 'contract_v1': contract_v1.name, - 'contract_v2': contract_v2.name, - 'variable': state_v1.name, - 'source_mapping': state_v1.source_mapping - }) + + json_elem = json_utils.generate_json_result(info) + json_utils.add_variable_to_json(state_v1, json_elem) + json_utils.add_contract_to_json(contract_v2, json_elem) + results['not_found_in_v2'].append(json_elem) + error_found = True if not error_found: diff --git a/tests/check-upgradeability/test_3.txt b/tests/check-upgradeability/test_3.txt index bf09a58ac..ebb21b107 100644 --- a/tests/check-upgradeability/test_3.txt +++ b/tests/check-upgradeability/test_3.txt @@ -12,7 +12,7 @@ No error found  ## Run function ids checks... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#functions-ids-checks) -Shadowing between proxy and implementation found myFunc() +Shadowing between ContractV2.myFunc (tests/check-upgradeability/contractV2_bug.sol#4) and Proxy.myFunc() (tests/check-upgradeability/proxy.sol#11)  ## Run variables ordering checks between ContractV2 and Proxy... (see https://github.com/crytic/slither/wiki/Upgradeability-Checks#variables-order-checks) Different variables between ContractV2 and Proxy: From 23ea41e007fd658952c06f0377d8a92f53253abf Mon Sep 17 00:00:00 2001 From: Josselin Date: Sat, 26 Oct 2019 15:00:54 +0200 Subject: [PATCH 205/223] Create Json output for printers (fix #286) --- slither/__main__.py | 55 +++++++++++-------- slither/printers/abstract_printer.py | 9 +++ slither/printers/call/call_graph.py | 25 +++++++-- slither/printers/functions/authorization.py | 16 +++++- slither/printers/functions/cfg.py | 17 +++++- slither/printers/guidance/echidna.py | 4 +- slither/printers/inheritance/inheritance.py | 23 ++++++++ .../printers/inheritance/inheritance_graph.py | 18 ++++-- slither/printers/summary/constructor_calls.py | 6 +- slither/printers/summary/contract.py | 15 +++++ slither/printers/summary/data_depenency.py | 12 ++++ slither/printers/summary/function.py | 14 +++++ slither/printers/summary/function_ids.py | 11 +++- slither/printers/summary/human_summary.py | 40 ++++++++++++++ slither/printers/summary/modifier_calls.py | 11 ++++ slither/printers/summary/require_calls.py | 11 ++++ slither/printers/summary/slithir.py | 1 - slither/printers/summary/variable_order.py | 13 +++++ slither/utils/command_line.py | 4 +- slither/utils/json_utils.py | 44 +++++++++++++++ 20 files changed, 305 insertions(+), 44 deletions(-) diff --git a/slither/__main__.py b/slither/__main__.py index a2b3a395b..a5f6dc4d6 100644 --- a/slither/__main__.py +++ b/slither/__main__.py @@ -25,7 +25,7 @@ from slither.utils.colors import red, yellow, set_colorization_enabled from slither.utils.command_line import (output_detectors, output_results_to_markdown, output_detectors_json, output_printers, output_printers_json, output_to_markdown, output_wiki, defaults_flag_in_config, - read_config_file, JSON_OUTPUT_TYPES) + read_config_file, JSON_OUTPUT_TYPES, DEFAULT_JSON_OUTPUT_TYPES) from crytic_compile import compile_all, is_supported from slither.exceptions import SlitherException @@ -59,14 +59,16 @@ def process_single(target, args, detector_classes, printer_classes): def process_all(target, args, detector_classes, printer_classes): compilations = compile_all(target, **vars(args)) slither_instances = [] - results = [] + results_detectors = [] + results_printers = [] analyzed_contracts_count = 0 for compilation in compilations: - (slither, current_results, current_analyzed_count) = process_single(compilation, args, detector_classes, printer_classes) - results.extend(current_results) + (slither, current_results_detectors, current_results_printers, current_analyzed_count) = process_single(compilation, args, detector_classes, printer_classes) + results_detectors.extend(current_results_detectors) + results_printers.extend(current_results_printers) slither_instances.append(slither) analyzed_contracts_count += current_analyzed_count - return slither_instances, results, analyzed_contracts_count + return slither_instances, results_detectors, results_printers, analyzed_contracts_count def _process(slither, detector_classes, printer_classes): @@ -78,18 +80,21 @@ def _process(slither, detector_classes, printer_classes): analyzed_contracts_count = len(slither.contracts) - results = [] + results_detectors = [] + results_printers = [] if not printer_classes: 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_detectors.extend(detector_results) - results.extend(detector_results) - - slither.run_printers() # Currently printers does not return results + else: + printer_results = slither.run_printers() + printer_results = [x for x in printer_results if x] # remove empty results + results_printers.extend(printer_results) - return slither, results, analyzed_contracts_count + return slither, results_detectors, results_printers, analyzed_contracts_count def process_from_asts(filenames, args, detector_classes, printer_classes): @@ -320,9 +325,9 @@ def parse_args(detector_classes, printer_classes): default=defaults_flag_in_config['json']) group_misc.add_argument('--json-types', - help='Comma-separated list of result types to output to JSON, defaults to all, ' - 'available types: {}'.format( - ', '.join(output_type for output_type in JSON_OUTPUT_TYPES)), + help=f'Comma-separated list of result types to output to JSON, defaults to ' +\ + f'{",".join(output_type for output_type in DEFAULT_JSON_OUTPUT_TYPES)}. ' +\ + f'Available types: {",".join(output_type for output_type in JSON_OUTPUT_TYPES)}', action='store', default=defaults_flag_in_config['json-types']) @@ -548,21 +553,23 @@ def main_impl(all_detector_classes, all_printer_classes): if not filenames: filenames = globbed_filenames number_contracts = 0 - results = [] + results_detectors = [] + results_printers = [] slither_instances = [] if args.splitted: - (slither_instance, results, number_contracts) = process_from_asts(filenames, args, detector_classes, printer_classes) + (slither_instance, results_detectors, results_printers, number_contracts) = process_from_asts(filenames, args, detector_classes, printer_classes) slither_instances.append(slither_instance) else: for filename in filenames: - (slither_instance, results_tmp, number_contracts_tmp) = process_single(filename, args, detector_classes, printer_classes) + (slither_instance, results_detectors_tmp, results_printers_tmp, number_contracts_tmp) = process_single(filename, args, detector_classes, printer_classes) number_contracts += number_contracts_tmp - results += results_tmp + results_detectors += results_detectors_tmp + results_printers += results_printers_tmp slither_instances.append(slither_instance) # Rely on CryticCompile to discern the underlying type of compilations. else: - (slither_instances, results, number_contracts) = process_all(filename, args, detector_classes, printer_classes) + (slither_instances, results_detectors, results_printers, number_contracts) = process_all(filename, args, detector_classes, printer_classes) # Determine if we are outputting JSON if outputting_json: @@ -574,8 +581,12 @@ def main_impl(all_detector_classes, all_printer_classes): json_results['compilations'] = compilation_results # Add our detector results to JSON if desired. - if results and 'detectors' in args.json_types: - json_results['detectors'] = results + if results_detectors and 'detectors' in args.json_types: + json_results['detectors'] = results_detectors + + # Add our printer results to JSON if desired. + if results_printers and 'printers' in args.json_types: + json_results['printers'] = results_printers # Add our detector types to JSON if 'list-detectors' in args.json_types: @@ -589,7 +600,7 @@ def main_impl(all_detector_classes, all_printer_classes): # Output our results to markdown if we wish to compile a checklist. if args.checklist: - output_results_to_markdown(results) + output_results_to_markdown(results_detectors) # Dont print the number of result for printers if number_contracts == 0: @@ -626,7 +637,7 @@ def main_impl(all_detector_classes, all_printer_classes): if output_error: sys.exit(-1) else: - exit(results) + exit(len(results_detectors)) if __name__ == '__main__': diff --git a/slither/printers/abstract_printer.py b/slither/printers/abstract_printer.py index 4926c1de2..5f9cbd6c9 100644 --- a/slither/printers/abstract_printer.py +++ b/slither/printers/abstract_printer.py @@ -1,5 +1,7 @@ import abc +from slither.utils import json_utils + class IncorrectPrinterInitialization(Exception): pass @@ -30,6 +32,13 @@ class AbstractPrinter(metaclass=abc.ABCMeta): if self.logger: self.logger.info(info) + + def generate_json_result(self, info, additional_fields={}): + d = json_utils.generate_json_result(info, additional_fields) + d['printer'] = self.ARGUMENT + + return d + @abc.abstractmethod def output(self, filename): """TODO Documentation""" diff --git a/slither/printers/call/call_graph.py b/slither/printers/call/call_graph.py index 4c9b9e385..285635163 100644 --- a/slither/printers/call/call_graph.py +++ b/slither/printers/call/call_graph.py @@ -16,6 +16,9 @@ from slither.core.variables.variable import Variable from slither.core.solidity_types.user_defined_type import UserDefinedType # return unique id for contract to use as subgraph name +from slither.utils import json_utils + + def _contract_subgraph(contract): return f'cluster_{contract.id}_{contract.name}' @@ -163,13 +166,25 @@ class PrinterCallGraph(AbstractPrinter): if filename == ".dot": filename = "all_contracts.dot" + info = '' + results = [] with open(filename, 'w', encoding='utf8') as f: - self.info(f'Call Graph: {filename}') - f.write('\n'.join(['strict digraph {'] + [self._process_functions(self.slither.functions)] + ['}'])) - + info += f'Call Graph: {filename}' + content = '\n'.join(['strict digraph {'] + [self._process_functions(self.slither.functions)] + ['}']) + f.write(content) + results.append((filename, content)) for derived_contract in self.slither.contracts_derived: with open(f'{derived_contract.name}.dot', 'w', encoding='utf8') as f: - self.info(f'Call Graph: {derived_contract.name}.dot') - f.write('\n'.join(['strict digraph {'] + [self._process_functions(derived_contract.functions)] + ['}'])) + info += f'Call Graph: {derived_contract.name}.dot' + content = '\n'.join(['strict digraph {'] + [self._process_functions(derived_contract.functions)] + ['}']) + f.write(content) + results.append((filename, content)) + + self.info(info) + json = self.generate_json_result(info) + for filename, content in results: + json_utils.add_file_to_json(filename, content, json) + + return json diff --git a/slither/printers/functions/authorization.py b/slither/printers/functions/authorization.py index 00af8f1a6..e934c28d7 100644 --- a/slither/printers/functions/authorization.py +++ b/slither/printers/functions/authorization.py @@ -5,6 +5,8 @@ from prettytable import PrettyTable from slither.printers.abstract_printer import AbstractPrinter from slither.core.declarations.function import Function +from slither.utils import json_utils + class PrinterWrittenVariablesAndAuthorization(AbstractPrinter): @@ -33,12 +35,22 @@ class PrinterWrittenVariablesAndAuthorization(AbstractPrinter): _filename(string) """ + txt = '' + all_tables = [] for contract in self.contracts: - txt = "\nContract %s\n"%contract.name + txt += "\nContract %s\n"%contract.name table = PrettyTable(["Function", "State variables written", "Conditions on msg.sender"]) for function in contract.functions: state_variables_written = [v.name for v in function.all_state_variables_written()] msg_sender_condition = self.get_msg_sender_checks(function) table.add_row([function.name, str(state_variables_written), str(msg_sender_condition)]) - self.info(txt + str(table)) + all_tables.append((contract.name, table)) + txt += str(table) + '\n' + + self.info(txt) + json = self.generate_json_result(txt) + for name, table in all_tables: + json_utils.add_pretty_table_to_json(table, name, json) + + return json \ No newline at end of file diff --git a/slither/printers/functions/cfg.py b/slither/printers/functions/cfg.py index 06be72636..09a76a1c6 100644 --- a/slither/printers/functions/cfg.py +++ b/slither/printers/functions/cfg.py @@ -3,6 +3,8 @@ from slither.printers.abstract_printer import AbstractPrinter from slither.core.declarations.function import Function +from slither.utils import json_utils + class CFG(AbstractPrinter): @@ -18,9 +20,20 @@ class CFG(AbstractPrinter): _filename(string) """ + info = '' + all_files = [] for contract in self.contracts: for function in contract.functions + contract.modifiers: filename = "{}-{}-{}.dot".format(original_filename, contract.name, function.full_name) - self.info('Export {}'.format(filename)) - function.slithir_cfg_to_dot(filename) + info += 'Export {}'.format(filename) + content = function.slithir_cfg_to_dot(filename) + with open(filename, 'w', encoding='utf8') as f: + f.write(content) + all_files.append((filename, content)) + + self.info(info) + json = self.generate_json_result(info) + for filename, content in all_files: + json_utils.add_file_to_json(filename, content, json) + return json \ No newline at end of file diff --git a/slither/printers/guidance/echidna.py b/slither/printers/guidance/echidna.py index 288a4d1f5..f2034aa17 100644 --- a/slither/printers/guidance/echidna.py +++ b/slither/printers/guidance/echidna.py @@ -138,4 +138,6 @@ class Echidna(AbstractPrinter): 'constants_used': cst_used, 'constants_used_in_binary': cst_used_in_binary} - print(json.dumps(d, indent=4)) \ No newline at end of file + self.info(json.dumps(d, indent=4)) + + return d \ No newline at end of file diff --git a/slither/printers/inheritance/inheritance.py b/slither/printers/inheritance/inheritance.py index c80fa7cb2..d151b6486 100644 --- a/slither/printers/inheritance/inheritance.py +++ b/slither/printers/inheritance/inheritance.py @@ -5,6 +5,7 @@ """ from slither.printers.abstract_printer import AbstractPrinter +from slither.utils import json_utils from slither.utils.colors import blue, green @@ -35,24 +36,46 @@ class PrinterInheritance(AbstractPrinter): info += blue('Child_Contract -> ') + green('Immediate_Base_Contracts') info += green(' [Not_Immediate_Base_Contracts]') + + result = {} + result['child_to_base'] = {} + for child in self.contracts: info += blue(f'\n+ {child.name}') + result['child_to_base'][child.name] = {'immediate': [], + 'not_immediate': []} if child.inheritance: + immediate = child.immediate_inheritance not_immediate = [i for i in child.inheritance if i not in immediate] + info += ' -> ' + green(", ".join(map(str, immediate))) + result['child_to_base'][child.name]['immediate'] = list(map(str, immediate)) if not_immediate: info += ", ["+ green(", ".join(map(str, not_immediate))) + "]" + result['child_to_base'][child.name]['not_immediate'] = list(map(str, not_immediate)) info += green('\n\nBase_Contract -> ') + blue('Immediate_Child_Contracts') info += blue(' [Not_Immediate_Child_Contracts]') + + result['base_to_child'] = {} for base in self.contracts: info += green(f'\n+ {base.name}') children = list(self._get_child_contracts(base)) + + result['base_to_child'][base.name] = {'immediate': [], + 'not_immediate': []} if children: immediate = [child for child in children if base in child.immediate_inheritance] not_immediate = [child for child in children if not child in immediate] + info += ' -> ' + blue(", ".join(map(str, immediate))) + result['base_to_child'][base.name]['immediate'] = list(map(str, immediate)) if not_immediate: info += ', [' + blue(", ".join(map(str, not_immediate))) + ']' + result['base_to_child'][base.name]['not_immediate'] = list(map(str, immediate)) self.info(info) + + json = self.generate_json_result(info, additional_fields=result) + + return json diff --git a/slither/printers/inheritance/inheritance_graph.py b/slither/printers/inheritance/inheritance_graph.py index 4dbed9e0b..529c4bdd9 100644 --- a/slither/printers/inheritance/inheritance_graph.py +++ b/slither/printers/inheritance/inheritance_graph.py @@ -9,6 +9,7 @@ from slither.core.declarations.contract import Contract from slither.core.solidity_types.user_defined_type import UserDefinedType from slither.printers.abstract_printer import AbstractPrinter +from slither.utils import json_utils from slither.utils.inheritance_analysis import (detect_c3_function_shadowing, detect_state_variable_shadowing) @@ -156,14 +157,23 @@ class PrinterInheritanceGraph(AbstractPrinter): Args: filename(string) """ + if filename == '': filename = 'contracts.dot' if not filename.endswith('.dot'): filename += ".dot" info = 'Inheritance Graph: ' + filename self.info(info) + + content = 'digraph "" {\n' + for c in self.contracts: + content += self._summary(c) + '\n' + content += '}' + with open(filename, 'w', encoding='utf8') as f: - f.write('digraph "" {\n') - for c in self.contracts: - f.write(self._summary(c)) - f.write('}') + f.write(content) + + json = self.generate_json_result(info) + json_utils.add_file_to_json(filename, content, json) + + return json \ No newline at end of file diff --git a/slither/printers/summary/constructor_calls.py b/slither/printers/summary/constructor_calls.py index 66e64d626..d0edb93be 100644 --- a/slither/printers/summary/constructor_calls.py +++ b/slither/printers/summary/constructor_calls.py @@ -35,13 +35,13 @@ class ConstructorPrinter(AbstractPrinter): stack_definition.append(self._get_soruce_code(cst)) if len(stack_name)>0: print(" ",stack_name[len(stack_name)-1], sep=' ', end='', flush=True) - count = len(stack_name)-2; + count = len(stack_name)-2 while count>=0: print("-->",stack_name[count], sep=' ', end='', flush=True) - count= count-1; + count= count-1 print("\n Constructor Definitions:") count = len(stack_definition)-1 while count>=0: print("\n Contract name:", stack_name[count]) print ("\n", stack_definition[count]) - count = count-1; + count = count-1 diff --git a/slither/printers/summary/contract.py b/slither/printers/summary/contract.py index 63a13fb95..ef4d13d6a 100644 --- a/slither/printers/summary/contract.py +++ b/slither/printers/summary/contract.py @@ -3,6 +3,7 @@ """ import collections from slither.printers.abstract_printer import AbstractPrinter +from slither.utils import json_utils from slither.utils.colors import blue, green, magenta class ContractSummary(AbstractPrinter): @@ -20,9 +21,11 @@ class ContractSummary(AbstractPrinter): """ txt = "" + result = {} for c in self.contracts: (name, _inheritance, _var, func_summaries, _modif_summaries) = c.get_summary(False) txt += blue("\n+ Contract %s\n"%name) + result[name] = {} # (c_name, f_name, visi, _, _, _, _, _) in func_summaries public = [(elem[0], (elem[1], elem[2]) ) for elem in func_summaries] @@ -33,15 +36,27 @@ class ContractSummary(AbstractPrinter): for contract, functions in public: txt += blue(" - From {}\n".format(contract)) + result[name]['from'] = str(contract) functions = sorted(functions) + result[name]['functions'] = {} + result[name]['functions']['visible'] = [] + result[name]['functions']['invisible'] = [] + result[name]['functions']['others'] = [] for (function, visi) in functions: if visi in ['external', 'public']: + result[name]['functions']['visible'].append({'function': function, 'visi': visi}) txt += green(" - {} ({})\n".format(function, visi)) for (function, visi) in functions: if visi in ['internal', 'private']: + result[name]['functions']['invisible'].append({'function': function, 'visi': visi}) txt += magenta(" - {} ({})\n".format(function, visi)) for (function, visi) in functions: if visi not in ['external', 'public', 'internal', 'private']: + result[name]['functions']['others'].append({'function': function, 'visi': visi}) txt += " - {}  ({})\n".format(function, visi) self.info(txt) + + json = self.generate_json_result(txt, additional_fields=result) + + return json \ No newline at end of file diff --git a/slither/printers/summary/data_depenency.py b/slither/printers/summary/data_depenency.py index c8fb38277..e30814f81 100644 --- a/slither/printers/summary/data_depenency.py +++ b/slither/printers/summary/data_depenency.py @@ -25,6 +25,9 @@ class DataDependency(AbstractPrinter): _filename(string) """ + all_tables = [] + all_txt = '' + txt = '' for c in self.contracts: txt += "\nContract %s\n"%c.name @@ -44,3 +47,12 @@ class DataDependency(AbstractPrinter): table.add_row([v.canonical_name, _get(v, f)]) txt += str(table) self.info(txt) + + all_txt += txt + all_tables.append((c.name, table)) + + json = self.generate_json_result(all_txt) + for name, table in all_tables: + json_utils.add_pretty_table_to_json(table, name, json) + + return json diff --git a/slither/printers/summary/function.py b/slither/printers/summary/function.py index 13650ba74..b9659cf03 100644 --- a/slither/printers/summary/function.py +++ b/slither/printers/summary/function.py @@ -4,6 +4,8 @@ from prettytable import PrettyTable from slither.printers.abstract_printer import AbstractPrinter +from slither.utils import json_utils + class FunctionSummary(AbstractPrinter): @@ -28,6 +30,9 @@ class FunctionSummary(AbstractPrinter): _filename(string) """ + all_tables = [] + all_txt = '' + for c in self.contracts: (name, inheritance, var, func_summaries, modif_summaries) = c.get_summary() txt = "\nContract %s"%name @@ -62,3 +67,12 @@ class FunctionSummary(AbstractPrinter): txt += "\n\n"+str(table) txt += "\n" self.info(txt) + + all_tables.append((name, table)) + all_txt += txt + + json = self.generate_json_result(all_txt) + for name, table in all_tables: + json_utils.add_pretty_table_to_json(table, name, json) + + return json diff --git a/slither/printers/summary/function_ids.py b/slither/printers/summary/function_ids.py index 7d6539bf1..44bf9d7c6 100644 --- a/slither/printers/summary/function_ids.py +++ b/slither/printers/summary/function_ids.py @@ -1,11 +1,10 @@ """ Module printing summary of the contract """ -import collections from prettytable import PrettyTable from slither.printers.abstract_printer import AbstractPrinter -from slither.utils.colors import blue, green, magenta +from slither.utils import json_utils from slither.utils.function import get_function_id class FunctionIds(AbstractPrinter): @@ -23,6 +22,7 @@ class FunctionIds(AbstractPrinter): """ txt = '' + all_tables = [] for contract in self.slither.contracts_derived: txt += '\n{}:\n'.format(contract.name) table = PrettyTable(['Name', 'ID']) @@ -34,5 +34,12 @@ class FunctionIds(AbstractPrinter): sig = variable.function_name table.add_row([sig, hex(get_function_id(sig))]) txt += str(table) + '\n' + all_tables.append((contract.name, table)) self.info(txt) + + json = self.generate_json_result(txt) + for name, table in all_tables: + json_utils.add_pretty_table_to_json(table, name, json) + + return json \ No newline at end of file diff --git a/slither/printers/summary/human_summary.py b/slither/printers/summary/human_summary.py index d83fbb759..fcd635365 100644 --- a/slither/printers/summary/human_summary.py +++ b/slither/printers/summary/human_summary.py @@ -4,6 +4,7 @@ Module printing summary of the contract import logging from slither.printers.abstract_printer import AbstractPrinter +from slither.utils import json_utils from slither.utils.code_complexity import compute_cyclomatic_complexity from slither.utils.colors import green, red, yellow from slither.utils.standard_libraries import is_standard_library @@ -195,10 +196,20 @@ class PrinterHumanSummary(AbstractPrinter): txt = "\n" txt += self._compilation_type() + results = { + 'contracts': [], + 'number_lines': 0, + 'number_lines_in_dependencies': 0, + 'standard_libraries': [], + 'ercs': [], + } + lines_number = self._lines_number() if lines_number: total_lines, total_dep_lines = lines_number txt += f'Number of lines: {total_lines} (+ {total_dep_lines} in dependencies)\n' + results['number_lines'] = total_lines + results['number_lines__dependencies'] = total_dep_lines number_contracts, number_contracts_deps = self._number_contracts() txt += f'Number of contracts: {number_contracts} (+ {number_contracts_deps} in dependencies) \n\n' @@ -208,10 +219,12 @@ class PrinterHumanSummary(AbstractPrinter): libs = self._standard_libraries() if libs: txt += f'\nUse: {", ".join(libs)}\n' + results['standard_libraries'] = [str(l) for l in libs] ercs = self._ercs() if ercs: txt += f'ERCs: {", ".join(ercs)}\n' + results['ercs'] = [str(e) for e in ercs] for contract in self.slither.contracts_derived: txt += "\nContract {}\n".format(contract.name) @@ -226,3 +239,30 @@ class PrinterHumanSummary(AbstractPrinter): txt += self.get_summary_erc20(contract) self.info(txt) + + for contract in self.slither.contracts_derived: + optimization, info, low, medium, high = self._get_detectors_result() + contract_d = {'contract_name': contract.name, + 'is_complex_code': self._is_complex_code(contract), + 'optimization_issues': optimization, + 'informational_issues': info, + 'low_issues': low, + 'medium_issues': medium, + 'high_issues': high, + 'is_erc20': contract.is_erc20(), + 'number_functions': self._number_functions(contract)} + if contract_d['is_erc20']: + pause, mint_limited, race_condition_mitigated = self._get_summary_erc20(contract) + contract_d['erc20_pause'] = pause + if mint_limited is not None: + contract_d['erc20_can_mint'] = True + contract_d['erc20_mint_limited'] = mint_limited + else: + contract_d['erc20_can_mint'] = False + contract_d['erc20_race_condition_mitigated'] = race_condition_mitigated + results['contracts'].append(contract_d) + + json = self.generate_json_result(txt, additional_fields=results) + + return json + diff --git a/slither/printers/summary/modifier_calls.py b/slither/printers/summary/modifier_calls.py index b76736937..858a813ff 100644 --- a/slither/printers/summary/modifier_calls.py +++ b/slither/printers/summary/modifier_calls.py @@ -5,6 +5,8 @@ from prettytable import PrettyTable from slither.core.declarations import Function from slither.printers.abstract_printer import AbstractPrinter +from slither.utils import json_utils + class Modifiers(AbstractPrinter): @@ -20,6 +22,9 @@ class Modifiers(AbstractPrinter): _filename(string) """ + all_txt = '' + all_tables = [] + for contract in self.slither.contracts_derived: txt = "\nContract %s"%contract.name table = PrettyTable(["Function", @@ -35,3 +40,9 @@ class Modifiers(AbstractPrinter): table.add_row([function.name, [m.name for m in set(modifiers)]]) txt += "\n"+str(table) self.info(txt) + + json = self.generate_json_result(all_txt) + for name, table in all_tables: + json_utils.add_pretty_table_to_json(table, name, json) + + return json \ No newline at end of file diff --git a/slither/printers/summary/require_calls.py b/slither/printers/summary/require_calls.py index 34149b07c..ab2874d67 100644 --- a/slither/printers/summary/require_calls.py +++ b/slither/printers/summary/require_calls.py @@ -6,6 +6,7 @@ from prettytable import PrettyTable from slither.core.declarations import SolidityFunction from slither.printers.abstract_printer import AbstractPrinter from slither.slithir.operations import SolidityCall +from slither.utils import json_utils require_or_assert = [SolidityFunction("assert(bool)"), SolidityFunction("require(bool)"), @@ -29,6 +30,8 @@ class RequireOrAssert(AbstractPrinter): _filename(string) """ + all_tables = [] + all_txt = '' for contract in self.slither.contracts_derived: txt = "\nContract %s"%contract.name table = PrettyTable(["Function", @@ -40,3 +43,11 @@ class RequireOrAssert(AbstractPrinter): table.add_row([function.name, self._convert([str(m.expression) for m in set(require)])]) txt += "\n"+str(table) self.info(txt) + all_tables.append((contract.name, table)) + all_txt += txt + + json = self.generate_json_result(all_txt) + for name, table in all_tables: + json_utils.add_pretty_table_to_json(table, name, json) + + return json diff --git a/slither/printers/summary/slithir.py b/slither/printers/summary/slithir.py index 70696c6fa..3466d0212 100644 --- a/slither/printers/summary/slithir.py +++ b/slither/printers/summary/slithir.py @@ -3,7 +3,6 @@ """ from slither.printers.abstract_printer import AbstractPrinter -from slither.utils.colors import blue, green, magenta class PrinterSlithIR(AbstractPrinter): diff --git a/slither/printers/summary/variable_order.py b/slither/printers/summary/variable_order.py index 48d96356b..d0debe60a 100644 --- a/slither/printers/summary/variable_order.py +++ b/slither/printers/summary/variable_order.py @@ -4,6 +4,8 @@ from prettytable import PrettyTable from slither.printers.abstract_printer import AbstractPrinter +from slither.utils import json_utils + class VariableOrder(AbstractPrinter): @@ -20,12 +22,23 @@ class VariableOrder(AbstractPrinter): """ txt = '' + + all_tables = [] + for contract in self.slither.contracts_derived: txt += '\n{}:\n'.format(contract.name) table = PrettyTable(['Name', 'Type']) for variable in contract.state_variables_ordered: if not variable.is_constant: table.add_row([variable.canonical_name, str(variable.type)]) + + all_tables.append((contract.name, table)) txt += str(table) + '\n' self.info(txt) + + json = self.generate_json_result(txt) + for name, table in all_tables: + json_utils.add_pretty_table_to_json(table, name, json) + + return json \ No newline at end of file diff --git a/slither/utils/command_line.py b/slither/utils/command_line.py index ee9b70bbc..2ead86223 100644 --- a/slither/utils/command_line.py +++ b/slither/utils/command_line.py @@ -12,8 +12,8 @@ from .colors import yellow, red logger = logging.getLogger("Slither") -DEFAULT_JSON_OUTPUT_TYPES = ["detectors"] -JSON_OUTPUT_TYPES = ["compilations", "console", "detectors", "list-detectors", "list-printers"] +DEFAULT_JSON_OUTPUT_TYPES = ["detectors", "printers"] +JSON_OUTPUT_TYPES = ["compilations", "console", "detectors", "printers", "list-detectors", "list-printers"] # Those are the flags shared by the command line and the config file diff --git a/slither/utils/json_utils.py b/slither/utils/json_utils.py index b748a7a09..8aecc8230 100644 --- a/slither/utils/json_utils.py +++ b/slither/utils/json_utils.py @@ -297,6 +297,50 @@ def add_pragma_to_json(pragma, d, additional_fields=None): d['elements'].append(element) +# endregion +################################################################################### +################################################################################### +# region File +################################################################################### +################################################################################### + + +def add_file_to_json(filename, content, d, additional_fields=None): + if additional_fields is None: + additional_fields = {} + type_specific_fields = { + 'filename': filename, + 'content': content + } + element = _create_base_element('file', + type_specific_fields, + additional_fields) + + d['elements'].append(element) + + +# endregion +################################################################################### +################################################################################### +# region Pretty Table +################################################################################### +################################################################################### + + +def add_pretty_table_to_json(content, name, d, additional_fields=None): + if additional_fields is None: + additional_fields = {} + type_specific_fields = { + 'content': content, + 'name': name + } + element = _create_base_element('pretty_table', + type_specific_fields, + additional_fields) + + d['elements'].append(element) + + # endregion ################################################################################### ################################################################################### From 30910148d835af95395c05fc38893ec7dfe9c714 Mon Sep 17 00:00:00 2001 From: Xiao Liang Date: Mon, 28 Oct 2019 17:15:38 +0800 Subject: [PATCH 206/223] fix(detectors/attributes/incorrect_solc): report 0.5.11 as old version This fixes the report that 0.5.11 is an old version. --- slither/detectors/attributes/incorrect_solc.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/slither/detectors/attributes/incorrect_solc.py b/slither/detectors/attributes/incorrect_solc.py index 54991722f..105a72561 100644 --- a/slither/detectors/attributes/incorrect_solc.py +++ b/slither/detectors/attributes/incorrect_solc.py @@ -43,7 +43,7 @@ Use Solidity 0.4.25 or 0.5.3. Consider using the latest version of Solidity for # Indicates the allowed versions. ALLOWED_VERSIONS = ["0.4.25", "0.4.26", "0.5.3"] # Indicates the versions too recent. - TOO_RECENT_VERSIONS = ["0.5.4", "0.5.7", "0.5.8", "0.5.9", "0.5.10"] + TOO_RECENT_VERSIONS = ["0.5.4", "0.5.7", "0.5.8", "0.5.9", "0.5.10", "0.5.11"] # Indicates the versions that should not be used. BUGGY_VERSIONS = ["0.4.22", "0.5.5", "0.5.6", "^0.4.22", "^0.5.5", "^0.5.6"] From b2dc4fe48e73f36fe09798398ea9b3c4c05b730f Mon Sep 17 00:00:00 2001 From: Josselin Date: Mon, 4 Nov 2019 09:37:01 +0100 Subject: [PATCH 207/223] AbstractDetector: (re-)add the generic self.add_* functions --- slither/detectors/abstract_detector.py | 52 ++++++++++++++++++- .../detectors/attributes/const_functions.py | 7 ++- .../detectors/attributes/constant_pragma.py | 3 +- .../detectors/attributes/incorrect_solc.py | 3 +- slither/detectors/attributes/locked_ether.py | 5 +- .../erc/incorrect_erc20_interface.py | 3 +- .../erc/incorrect_erc721_interface.py | 3 +- .../erc/unindexed_event_parameters.py | 3 +- slither/detectors/examples/backdoor.py | 3 +- slither/detectors/functions/arbitrary_send.py | 5 +- .../detectors/functions/complex_function.py | 3 +- .../detectors/functions/external_function.py | 5 +- slither/detectors/functions/suicidal.py | 3 +- .../naming_convention/naming_convention.py | 21 ++++---- .../detectors/operations/block_timestamp.py | 5 +- .../detectors/operations/low_level_calls.py | 5 +- .../operations/unused_return_values.py | 5 +- .../detectors/operations/void_constructor.py | 5 +- slither/detectors/reentrancy/reentrancy.py | 10 ++-- .../detectors/reentrancy/reentrancy_benign.py | 17 ++---- .../detectors/reentrancy/reentrancy_eth.py | 16 ++---- .../reentrancy_read_before_write.py | 14 ++--- slither/detectors/shadowing/abstract.py | 3 +- .../detectors/shadowing/builtin_symbols.py | 7 ++- slither/detectors/shadowing/local.py | 9 ++-- slither/detectors/shadowing/state.py | 3 +- slither/detectors/source/rtlo.py | 10 ++-- slither/detectors/statements/assembly.py | 5 +- slither/detectors/statements/calls_in_loop.py | 3 +- .../statements/controlled_delegatecall.py | 5 +- .../detectors/statements/deprecated_calls.py | 5 +- .../statements/incorrect_strict_equality.py | 7 +-- .../detectors/statements/too_many_digits.py | 3 +- slither/detectors/statements/tx_origin.py | 3 +- .../possible_const_state_variables.py | 3 +- .../uninitialized_local_variables.py | 7 +-- .../uninitialized_state_variables.py | 12 ++--- .../uninitialized_storage_variables.py | 8 +-- .../variables/unused_state_variables.py | 6 +-- 39 files changed, 136 insertions(+), 159 deletions(-) diff --git a/slither/detectors/abstract_detector.py b/slither/detectors/abstract_detector.py index 6a05c4a5d..fb9aca05d 100644 --- a/slither/detectors/abstract_detector.py +++ b/slither/detectors/abstract_detector.py @@ -1,11 +1,11 @@ import abc import re -from collections import OrderedDict -from slither.utils import json_utils from slither.utils.colors import green, yellow, red from slither.formatters.exceptions import FormatImpossible from slither.formatters.utils.patches import apply_patch, create_diff +from slither.utils import json_utils + class IncorrectDetectorInitialization(Exception): pass @@ -177,6 +177,54 @@ class AbstractDetector(metaclass=abc.ABCMeta): return d + @staticmethod + def add_variable_to_json(e, d, additional_fields=None): + json_utils.add_variable_to_json(e, d, additional_fields=additional_fields) + + @staticmethod + def add_variables_to_json(e, d): + json_utils.add_variables_to_json(e, d) + + @staticmethod + def add_contract_to_json(e, d, additional_fields=None): + json_utils.add_contract_to_json(e, d, additional_fields=additional_fields) + + @staticmethod + def add_function_to_json(e, d, additional_fields=None): + json_utils.add_function_to_json(e, d, additional_fields=additional_fields) + + @staticmethod + def add_functions_to_json(e, d, additional_fields=None): + json_utils.add_functions_to_json(e, d, additional_fields=additional_fields) + + @staticmethod + def add_enum_to_json(e, d, additional_fields=None): + json_utils.add_enum_to_json(e, d, additional_fields=additional_fields) + + @staticmethod + def add_struct_to_json(e, d, additional_fields=None): + json_utils.add_struct_to_json(e, d, additional_fields=additional_fields) + + @staticmethod + def add_event_to_json(e, d, additional_fields=None): + json_utils.add_event_to_json(e, d, additional_fields=additional_fields) + + @staticmethod + def add_pragma_to_json(e, d, additional_fields=None): + json_utils.add_pragma_to_json(e, d, additional_fields=additional_fields) + + @staticmethod + def add_node_to_json(e, d, additional_fields=None): + json_utils.add_node_to_json(e, d, additional_fields=additional_fields) + + @staticmethod + def add_nodes_to_json(e, d): + json_utils.add_nodes_to_json(e, d) + + @staticmethod + def add_other_to_json(name, source_mapping, d, slither, additional_fields=None): + json_utils.add_other_to_json(name, source_mapping, d, slither, additional_fields=additional_fields) + @staticmethod def _format(slither, result): """Implement format""" diff --git a/slither/detectors/attributes/const_functions.py b/slither/detectors/attributes/const_functions.py index 438d19b39..7d5d492f4 100644 --- a/slither/detectors/attributes/const_functions.py +++ b/slither/detectors/attributes/const_functions.py @@ -4,7 +4,6 @@ Recursively check the called functions """ from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification from slither.formatters.attributes.const_functions import format -from slither.utils import json_utils class ConstantFunctions(AbstractDetector): @@ -61,7 +60,7 @@ All the calls to `get` revert, breaking Bob's smart contract execution.''' info = '{} ({}) is declared {} but contains assembly code\n' info = info.format(f.canonical_name, f.source_mapping_str, attr) json = self.generate_json_result(info, {'contains_assembly': True}) - json_utils.add_function_to_json(f, json) + self.add_function_to_json(f, json) results.append(json) variables_written = f.all_state_variables_written() @@ -73,8 +72,8 @@ All the calls to `get` revert, breaking Bob's smart contract execution.''' info += '\t- {}\n'.format(variable_written.canonical_name) json = self.generate_json_result(info, {'contains_assembly': False}) - json_utils.add_function_to_json(f, json) - json_utils.add_variables_to_json(variables_written, json) + self.add_function_to_json(f, json) + self.add_variables_to_json(variables_written, json) results.append(json) return results diff --git a/slither/detectors/attributes/constant_pragma.py b/slither/detectors/attributes/constant_pragma.py index 0af8c8ccb..0c2e54bca 100644 --- a/slither/detectors/attributes/constant_pragma.py +++ b/slither/detectors/attributes/constant_pragma.py @@ -4,7 +4,6 @@ from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification from slither.formatters.attributes.constant_pragma import format -from slither.utils import json_utils class ConstantPragma(AbstractDetector): @@ -40,7 +39,7 @@ class ConstantPragma(AbstractDetector): # Add each pragma to our elements for p in pragma: - json_utils.add_pragma_to_json(p, json) + self.add_pragma_to_json(p, json) results.append(json) return results diff --git a/slither/detectors/attributes/incorrect_solc.py b/slither/detectors/attributes/incorrect_solc.py index 040d90dfe..17dcd5204 100644 --- a/slither/detectors/attributes/incorrect_solc.py +++ b/slither/detectors/attributes/incorrect_solc.py @@ -12,7 +12,6 @@ from slither.formatters.attributes.incorrect_solc import format # 2: version number # 3: version number # 4: version number -from slither.utils import json_utils PATTERN = re.compile('(\^|>|>=|<|<=)?([ ]+)?(\d+)\.(\d+)\.(\d+)') @@ -104,7 +103,7 @@ Use Solidity 0.4.25 or 0.5.3. Consider using the latest version of Solidity for info = f"Pragma version \"{p.version}\" {reason} ({p.source_mapping_str})\n" json = self.generate_json_result(info) - json_utils.add_pragma_to_json(p, json) + self.add_pragma_to_json(p, json) results.append(json) return results diff --git a/slither/detectors/attributes/locked_ether.py b/slither/detectors/attributes/locked_ether.py index c24a8ee09..2a4e1d1c3 100644 --- a/slither/detectors/attributes/locked_ether.py +++ b/slither/detectors/attributes/locked_ether.py @@ -6,7 +6,6 @@ from slither.detectors.abstract_detector import (AbstractDetector, DetectorClassification) from slither.slithir.operations import (HighLevelCall, LowLevelCall, Send, Transfer, NewContract, LibraryCall, InternalCall) -from slither.utils import json_utils class LockedEther(AbstractDetector): @@ -85,8 +84,8 @@ Every ether sent to `Locked` will be lost.''' [f.name for f in funcs_payable]) json = self.generate_json_result(info) - json_utils.add_contract_to_json(contract, json) - json_utils.add_functions_to_json(funcs_payable, json) + self.add_contract_to_json(contract, json) + self.add_functions_to_json(funcs_payable, json) results.append(json) return results diff --git a/slither/detectors/erc/incorrect_erc20_interface.py b/slither/detectors/erc/incorrect_erc20_interface.py index 79fb73415..c2c0a4112 100644 --- a/slither/detectors/erc/incorrect_erc20_interface.py +++ b/slither/detectors/erc/incorrect_erc20_interface.py @@ -3,7 +3,6 @@ Detect incorrect erc20 interface. Some contracts do not return a bool on transfer/transferFrom/approve, which may lead to preventing the contract to be used with contracts compiled with recent solc (>0.4.22) """ from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification -from slither.utils import json_utils class IncorrectERC20InterfaceDetection(AbstractDetector): @@ -93,7 +92,7 @@ contract Token{ function.full_name, function.source_mapping_str) json = self.generate_json_result(info) - json_utils.add_function_to_json(function, json) + self.add_function_to_json(function, json) results.append(json) return results diff --git a/slither/detectors/erc/incorrect_erc721_interface.py b/slither/detectors/erc/incorrect_erc721_interface.py index e813bff73..bff88413c 100644 --- a/slither/detectors/erc/incorrect_erc721_interface.py +++ b/slither/detectors/erc/incorrect_erc721_interface.py @@ -2,7 +2,6 @@ Detect incorrect erc721 interface. """ from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification -from slither.utils import json_utils class IncorrectERC721InterfaceDetection(AbstractDetector): @@ -92,7 +91,7 @@ contract Token{ function.full_name, function.source_mapping_str) json = self.generate_json_result(info) - json_utils.add_function_to_json(function, json) + self.add_function_to_json(function, json) results.append(json) return results diff --git a/slither/detectors/erc/unindexed_event_parameters.py b/slither/detectors/erc/unindexed_event_parameters.py index 73887e0cb..55ab15e25 100644 --- a/slither/detectors/erc/unindexed_event_parameters.py +++ b/slither/detectors/erc/unindexed_event_parameters.py @@ -2,7 +2,6 @@ Detect mistakenly un-indexed ERC20 event parameters """ from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification -from slither.utils import json_utils class UnindexedERC20EventParameters(AbstractDetector): @@ -76,7 +75,7 @@ In this case, Transfer and Approval events should have the 'indexed' keyword on # Add the events to the JSON (note: we do not add the params/vars as they have no source mapping). json = self.generate_json_result(info) - json_utils.add_event_to_json(event, json, { + self.add_event_to_json(event, json, { "parameter_name": parameter.name }) results.append(json) diff --git a/slither/detectors/examples/backdoor.py b/slither/detectors/examples/backdoor.py index e95f31e51..bbc60a8b3 100644 --- a/slither/detectors/examples/backdoor.py +++ b/slither/detectors/examples/backdoor.py @@ -1,5 +1,4 @@ from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification -from slither.utils import json_utils class Backdoor(AbstractDetector): @@ -31,7 +30,7 @@ class Backdoor(AbstractDetector): info = info.format(contract.name, f.name, f.source_mapping_str) # Add the result in result json = self.generate_json_result(info) - json_utils.add_function_to_json(f, json) + self.add_function_to_json(f, json) results.append(json) return results diff --git a/slither/detectors/functions/arbitrary_send.py b/slither/detectors/functions/arbitrary_send.py index e38ff25eb..d28cd1258 100644 --- a/slither/detectors/functions/arbitrary_send.py +++ b/slither/detectors/functions/arbitrary_send.py @@ -17,7 +17,6 @@ from slither.detectors.abstract_detector import (AbstractDetector, DetectorClassification) from slither.slithir.operations import (HighLevelCall, Index, LowLevelCall, Send, SolidityCall, Transfer) -from slither.utils import json_utils class ArbitrarySend(AbstractDetector): @@ -118,8 +117,8 @@ Bob calls `setDestination` and `withdraw`. As a result he withdraws the contract info += '\t- {} ({})\n'.format(node.expression, node.source_mapping_str) json = self.generate_json_result(info) - json_utils.add_function_to_json(func, json) - json_utils.add_nodes_to_json(nodes, json) + self.add_function_to_json(func, json) + self.add_nodes_to_json(nodes, json) results.append(json) return results diff --git a/slither/detectors/functions/complex_function.py b/slither/detectors/functions/complex_function.py index d3668f216..fae9a0923 100644 --- a/slither/detectors/functions/complex_function.py +++ b/slither/detectors/functions/complex_function.py @@ -5,7 +5,6 @@ from slither.detectors.abstract_detector import (AbstractDetector, from slither.slithir.operations import (HighLevelCall, LowLevelCall, LibraryCall) -from slither.utils import json_utils from slither.utils.code_complexity import compute_cyclomatic_complexity @@ -106,7 +105,7 @@ class ComplexFunction(AbstractDetector): self.log(info) json = self.generate_json_result(info) - json_utils.add_function_to_json(func, json, { + self.add_function_to_json(func, json, { 'high_number_of_external_calls': cause == self.CAUSE_EXTERNAL_CALL, 'high_number_of_branches': cause == self.CAUSE_CYCLOMATIC, 'high_number_of_state_variables': cause == self.CAUSE_STATE_VARS diff --git a/slither/detectors/functions/external_function.py b/slither/detectors/functions/external_function.py index 3cc828418..233f24f48 100644 --- a/slither/detectors/functions/external_function.py +++ b/slither/detectors/functions/external_function.py @@ -3,7 +3,6 @@ from slither.detectors.abstract_detector import (AbstractDetector, from slither.slithir.operations import SolidityCall from slither.slithir.operations import (InternalCall, InternalDynamicCall) from slither.formatters.functions.external_function import format -from slither.utils import json_utils class ExternalFunction(AbstractDetector): @@ -190,9 +189,9 @@ class ExternalFunction(AbstractDetector): txt += f" ({other_function_definition.source_mapping_str})\n" json = self.generate_json_result(txt) - json_utils.add_function_to_json(function_definition, json) + self.add_function_to_json(function_definition, json) for other_function_definition in all_function_definitions: - json_utils.add_function_to_json(other_function_definition, json) + self.add_function_to_json(other_function_definition, json) results.append(json) return results diff --git a/slither/detectors/functions/suicidal.py b/slither/detectors/functions/suicidal.py index 443c2bd61..5f5d0f73b 100644 --- a/slither/detectors/functions/suicidal.py +++ b/slither/detectors/functions/suicidal.py @@ -5,7 +5,6 @@ A suicidal contract is an unprotected function that calls selfdestruct """ from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification -from slither.utils import json_utils class Suicidal(AbstractDetector): @@ -79,7 +78,7 @@ Bob calls `kill` and destructs the contract.''' func.source_mapping_str) json = self.generate_json_result(info) - json_utils.add_function_to_json(func, json) + self.add_function_to_json(func, json) results.append(json) return results diff --git a/slither/detectors/naming_convention/naming_convention.py b/slither/detectors/naming_convention/naming_convention.py index b012441b3..a6499ca99 100644 --- a/slither/detectors/naming_convention/naming_convention.py +++ b/slither/detectors/naming_convention/naming_convention.py @@ -1,7 +1,6 @@ import re from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification from slither.formatters.naming_convention.naming_convention import format -from slither.utils import json_utils class NamingConvention(AbstractDetector): @@ -64,7 +63,7 @@ Solidity defines a [naming convention](https://solidity.readthedocs.io/en/v0.4.2 contract.source_mapping_str) json = self.generate_json_result(info) - json_utils.add_contract_to_json(contract, json, { + self.add_contract_to_json(contract, json, { "target": "contract", "convention": "CapWords" }) @@ -76,7 +75,7 @@ Solidity defines a [naming convention](https://solidity.readthedocs.io/en/v0.4.2 info = info.format(struct.canonical_name, struct.source_mapping_str) json = self.generate_json_result(info) - json_utils.add_struct_to_json(struct, json, { + self.add_struct_to_json(struct, json, { "target": "structure", "convention": "CapWords" }) @@ -88,7 +87,7 @@ Solidity defines a [naming convention](https://solidity.readthedocs.io/en/v0.4.2 info = info.format(event.canonical_name, event.source_mapping_str) json = self.generate_json_result(info) - json_utils.add_event_to_json(event, json, { + self.add_event_to_json(event, json, { "target": "event", "convention": "CapWords" }) @@ -106,7 +105,7 @@ Solidity defines a [naming convention](https://solidity.readthedocs.io/en/v0.4.2 info = info.format(func.canonical_name, func.source_mapping_str) json = self.generate_json_result(info) - json_utils.add_function_to_json(func, json, { + self.add_function_to_json(func, json, { "target": "function", "convention": "mixedCase" }) @@ -127,7 +126,7 @@ Solidity defines a [naming convention](https://solidity.readthedocs.io/en/v0.4.2 argument.source_mapping_str) json = self.generate_json_result(info) - json_utils.add_variable_to_json(argument, json, { + self.add_variable_to_json(argument, json, { "target": "parameter", "convention": "mixedCase" }) @@ -140,7 +139,7 @@ Solidity defines a [naming convention](https://solidity.readthedocs.io/en/v0.4.2 info = info.format(var.canonical_name, var.source_mapping_str) json = self.generate_json_result(info) - json_utils.add_variable_to_json(var, json, { + self.add_variable_to_json(var, json, { "target": "variable", "convention": "l_O_I_should_not_be_used" }) @@ -156,7 +155,7 @@ Solidity defines a [naming convention](https://solidity.readthedocs.io/en/v0.4.2 info = info.format(var.canonical_name, var.source_mapping_str) json = self.generate_json_result(info) - json_utils.add_variable_to_json(var, json, { + self.add_variable_to_json(var, json, { "target": "variable_constant", "convention": "UPPER_CASE_WITH_UNDERSCORES" }) @@ -172,7 +171,7 @@ Solidity defines a [naming convention](https://solidity.readthedocs.io/en/v0.4.2 info = info.format(var.canonical_name, var.source_mapping_str) json = self.generate_json_result(info) - json_utils.add_variable_to_json(var, json, { + self.add_variable_to_json(var, json, { "target": "variable", "convention": "mixedCase" }) @@ -184,7 +183,7 @@ Solidity defines a [naming convention](https://solidity.readthedocs.io/en/v0.4.2 info = info.format(enum.canonical_name, enum.source_mapping_str) json = self.generate_json_result(info) - json_utils.add_enum_to_json(enum, json, { + self.add_enum_to_json(enum, json, { "target": "enum", "convention": "CapWords" }) @@ -197,7 +196,7 @@ Solidity defines a [naming convention](https://solidity.readthedocs.io/en/v0.4.2 modifier.source_mapping_str) json = self.generate_json_result(info) - json_utils.add_function_to_json(modifier, json, { + self.add_function_to_json(modifier, json, { "target": "modifier", "convention": "mixedCase" }) diff --git a/slither/detectors/operations/block_timestamp.py b/slither/detectors/operations/block_timestamp.py index f771c9a9d..81c115341 100644 --- a/slither/detectors/operations/block_timestamp.py +++ b/slither/detectors/operations/block_timestamp.py @@ -9,7 +9,6 @@ from slither.core.declarations.solidity_variables import (SolidityFunction, from slither.detectors.abstract_detector import (AbstractDetector, DetectorClassification) from slither.slithir.operations import Binary, BinaryType -from slither.utils import json_utils class Timestamp(AbstractDetector): @@ -78,8 +77,8 @@ class Timestamp(AbstractDetector): info += '\t- {} ({})\n'.format(node.expression, node.source_mapping_str) json = self.generate_json_result(info) - json_utils.add_function_to_json(func, json) - json_utils.add_nodes_to_json(nodes, json) + self.add_function_to_json(func, json) + self.add_nodes_to_json(nodes, json) results.append(json) return results diff --git a/slither/detectors/operations/low_level_calls.py b/slither/detectors/operations/low_level_calls.py index 66ed88a6e..4e36448a4 100644 --- a/slither/detectors/operations/low_level_calls.py +++ b/slither/detectors/operations/low_level_calls.py @@ -4,7 +4,6 @@ Module detecting usage of low level calls from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification from slither.slithir.operations import LowLevelCall -from slither.utils import json_utils class LowLevelCalls(AbstractDetector): @@ -55,8 +54,8 @@ class LowLevelCalls(AbstractDetector): info += "\t-{} {}\n".format(str(node.expression), node.source_mapping_str) json = self.generate_json_result(info) - json_utils.add_function_to_json(func, json) - json_utils.add_nodes_to_json(nodes, json) + self.add_function_to_json(func, json) + self.add_nodes_to_json(nodes, json) results.append(json) return results diff --git a/slither/detectors/operations/unused_return_values.py b/slither/detectors/operations/unused_return_values.py index 1355eeca4..77a0e5b86 100644 --- a/slither/detectors/operations/unused_return_values.py +++ b/slither/detectors/operations/unused_return_values.py @@ -5,7 +5,6 @@ Module detecting unused return values from external calls from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification from slither.slithir.operations import HighLevelCall, InternalCall, InternalDynamicCall from slither.core.variables.state_variable import StateVariable -from slither.utils import json_utils class UnusedReturnValues(AbstractDetector): @@ -83,8 +82,8 @@ contract MyConc{ node.source_mapping_str) json = self.generate_json_result(info) - json_utils.add_node_to_json(node, json) - json_utils.add_function_to_json(f, json) + self.add_node_to_json(node, json) + self.add_function_to_json(f, json) results.append(json) return results diff --git a/slither/detectors/operations/void_constructor.py b/slither/detectors/operations/void_constructor.py index 9a1e8833c..6be913ffa 100644 --- a/slither/detectors/operations/void_constructor.py +++ b/slither/detectors/operations/void_constructor.py @@ -1,7 +1,6 @@ from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification from slither.slithir.operations import Nop -from slither.utils import json_utils class VoidConstructor(AbstractDetector): @@ -42,7 +41,7 @@ By reading B's constructor definition, the reader might assume that `A()` initia info += "\t-{} {}\n".format(str(node.expression), node.source_mapping_str) json = self.generate_json_result(info) - json_utils.add_function_to_json(cst, json) - json_utils.add_nodes_to_json([node], json) + self.add_function_to_json(cst, json) + self.add_nodes_to_json([node], json) results.append(json) return results diff --git a/slither/detectors/reentrancy/reentrancy.py b/slither/detectors/reentrancy/reentrancy.py index add10ad58..bb5afef17 100644 --- a/slither/detectors/reentrancy/reentrancy.py +++ b/slither/detectors/reentrancy/reentrancy.py @@ -6,13 +6,11 @@ """ from slither.core.cfg.node import NodeType -from slither.core.declarations import Function, SolidityFunction, SolidityVariable +from slither.core.declarations import Function from slither.core.expressions import UnaryOperation, UnaryOperationType -from slither.detectors.abstract_detector import (AbstractDetector, - DetectorClassification) -from slither.slithir.operations import (HighLevelCall, LowLevelCall, - Call, - Send, Transfer) +from slither.detectors.abstract_detector import AbstractDetector +from slither.slithir.operations import Call + def union_dict(d1, d2): d3 = {k: d1.get(k, set()) | d2.get(k, set()) for k in set(list(d1.keys()) + list(d2.keys()))} diff --git a/slither/detectors/reentrancy/reentrancy_benign.py b/slither/detectors/reentrancy/reentrancy_benign.py index 52df78ff2..2d16d757f 100644 --- a/slither/detectors/reentrancy/reentrancy_benign.py +++ b/slither/detectors/reentrancy/reentrancy_benign.py @@ -5,15 +5,8 @@ Iterate over all the nodes of the graph until reaching a fixpoint """ -from slither.core.cfg.node import NodeType -from slither.core.declarations import Function, SolidityFunction -from slither.core.expressions import UnaryOperation, UnaryOperationType from slither.detectors.abstract_detector import DetectorClassification -from slither.utils import json_utils -from slither.visitors.expression.export_values import ExportValues -from slither.slithir.operations import (HighLevelCall, LowLevelCall, - LibraryCall, - Send, Transfer) + from .reentrancy import Reentrancy @@ -102,11 +95,11 @@ Only report reentrancy that acts as a double call (see `reentrancy-eth`, `reentr json = self.generate_json_result(info) # Add the function with the re-entrancy first - json_utils.add_function_to_json(func, json) + self.add_function_to_json(func, json) # Add all underlying calls in the function which are potentially problematic. for call_info in calls: - json_utils.add_node_to_json(call_info, json, { + self.add_node_to_json(call_info, json, { "underlying_type": "external_calls" }) @@ -115,13 +108,13 @@ Only report reentrancy that acts as a double call (see `reentrancy-eth`, `reentr # If the calls are not the same ones that send eth, add the eth sending nodes. if calls != send_eth: for call_info in send_eth: - json_utils.add_node_to_json(call_info, json, { + self.add_node_to_json(call_info, json, { "underlying_type": "external_calls_sending_eth" }) # Add all variables written via nodes which write them. for (v, node) in varsWritten: - json_utils.add_node_to_json(node, json, { + self.add_node_to_json(node, json, { "underlying_type": "variables_written", "variable_name": v.name }) diff --git a/slither/detectors/reentrancy/reentrancy_eth.py b/slither/detectors/reentrancy/reentrancy_eth.py index ac838deee..4439887aa 100644 --- a/slither/detectors/reentrancy/reentrancy_eth.py +++ b/slither/detectors/reentrancy/reentrancy_eth.py @@ -4,14 +4,8 @@ Based on heuristics, it may lead to FP and FN Iterate over all the nodes of the graph until reaching a fixpoint """ -from slither.core.cfg.node import NodeType -from slither.core.declarations import Function, SolidityFunction -from slither.core.expressions import UnaryOperation, UnaryOperationType from slither.detectors.abstract_detector import DetectorClassification -from slither.slithir.operations import (HighLevelCall, LowLevelCall, - LibraryCall, - Send, Transfer) -from slither.utils import json_utils + from .reentrancy import Reentrancy class ReentrancyEth(Reentrancy): @@ -104,11 +98,11 @@ Bob uses the re-entrancy bug to call `withdrawBalance` two times, and withdraw m json = self.generate_json_result(info) # Add the function with the re-entrancy first - json_utils.add_function_to_json(func, json) + self.add_function_to_json(func, json) # Add all underlying calls in the function which are potentially problematic. for call_info in calls: - json_utils.add_node_to_json(call_info, json, { + self.add_node_to_json(call_info, json, { "underlying_type": "external_calls" }) @@ -117,13 +111,13 @@ Bob uses the re-entrancy bug to call `withdrawBalance` two times, and withdraw m # If the calls are not the same ones that send eth, add the eth sending nodes. if calls != send_eth: for call_info in send_eth: - json_utils.add_node_to_json(call_info, json, { + self.add_node_to_json(call_info, json, { "underlying_type": "external_calls_sending_eth" }) # Add all variables written via nodes which write them. for (v, node) in varsWritten: - json_utils.add_node_to_json(node, json, { + self.add_node_to_json(node, json, { "underlying_type": "variables_written", "variable_name": v.name }) diff --git a/slither/detectors/reentrancy/reentrancy_read_before_write.py b/slither/detectors/reentrancy/reentrancy_read_before_write.py index 0d670ad32..0432459cc 100644 --- a/slither/detectors/reentrancy/reentrancy_read_before_write.py +++ b/slither/detectors/reentrancy/reentrancy_read_before_write.py @@ -5,15 +5,7 @@ Iterate over all the nodes of the graph until reaching a fixpoint """ -from slither.core.cfg.node import NodeType -from slither.core.declarations import Function, SolidityFunction -from slither.core.expressions import UnaryOperation, UnaryOperationType from slither.detectors.abstract_detector import DetectorClassification -from slither.utils import json_utils -from slither.visitors.expression.export_values import ExportValues -from slither.slithir.operations import (HighLevelCall, LowLevelCall, - LibraryCall, - Send, Transfer) from .reentrancy import Reentrancy @@ -96,17 +88,17 @@ Do not report reentrancies that involve ethers (see `reentrancy-eth`)''' json = self.generate_json_result(info) # Add the function with the re-entrancy first - json_utils.add_function_to_json(func, json) + self.add_function_to_json(func, json) # Add all underlying calls in the function which are potentially problematic. for call_info in calls: - json_utils.add_node_to_json(call_info, json, { + self.add_node_to_json(call_info, json, { "underlying_type": "external_calls" }) # Add all variables written via nodes which write them. for (v, node) in varsWritten: - json_utils.add_node_to_json(node, json, { + self.add_node_to_json(node, json, { "underlying_type": "variables_written", "variable_name": v.name }) diff --git a/slither/detectors/shadowing/abstract.py b/slither/detectors/shadowing/abstract.py index 5cdb3327e..15bb7e2c1 100644 --- a/slither/detectors/shadowing/abstract.py +++ b/slither/detectors/shadowing/abstract.py @@ -4,7 +4,6 @@ Recursively check the called functions """ from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification -from slither.utils import json_utils class ShadowingAbstractDetection(AbstractDetector): @@ -73,7 +72,7 @@ contract DerivedContract is BaseContract{ var.source_mapping_str) json = self.generate_json_result(info) - json_utils.add_variables_to_json(all_variables, json) + self.add_variables_to_json(all_variables, json) results.append(json) return results diff --git a/slither/detectors/shadowing/builtin_symbols.py b/slither/detectors/shadowing/builtin_symbols.py index e1f7ee6fb..2cd4cff09 100644 --- a/slither/detectors/shadowing/builtin_symbols.py +++ b/slither/detectors/shadowing/builtin_symbols.py @@ -3,7 +3,6 @@ Module detecting reserved keyword shadowing """ from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification -from slither.utils import json_utils class BuiltinSymbolShadowing(AbstractDetector): @@ -141,11 +140,11 @@ contract Bug { # Generate relevant JSON data for this shadowing definition. json = self.generate_json_result(info) if shadow_type in [self.SHADOWING_FUNCTION, self.SHADOWING_MODIFIER]: - json_utils.add_function_to_json(shadow_object, json) + self.add_function_to_json(shadow_object, json) elif shadow_type == self.SHADOWING_EVENT: - json_utils.add_event_to_json(shadow_object, json) + self.add_event_to_json(shadow_object, json) elif shadow_type in [self.SHADOWING_STATE_VARIABLE, self.SHADOWING_LOCAL_VARIABLE]: - json_utils.add_variable_to_json(shadow_object, json) + self.add_variable_to_json(shadow_object, json) results.append(json) return results diff --git a/slither/detectors/shadowing/local.py b/slither/detectors/shadowing/local.py index 63c3c592c..66f769882 100644 --- a/slither/detectors/shadowing/local.py +++ b/slither/detectors/shadowing/local.py @@ -3,7 +3,6 @@ Module detecting local variable shadowing """ from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification -from slither.utils import json_utils class LocalShadowing(AbstractDetector): @@ -118,14 +117,14 @@ contract Bug { # Generate relevant JSON data for this shadowing definition. json = self.generate_json_result(info) - json_utils.add_variable_to_json(local_variable, json) + self.add_variable_to_json(local_variable, json) for overshadowed_entry in overshadowed: if overshadowed_entry[0] in [self.OVERSHADOWED_FUNCTION, self.OVERSHADOWED_MODIFIER]: - json_utils.add_function_to_json(overshadowed_entry[2], json) + self.add_function_to_json(overshadowed_entry[2], json) elif overshadowed_entry[0] == self.OVERSHADOWED_EVENT: - json_utils.add_event_to_json(overshadowed_entry[2], json) + self.add_event_to_json(overshadowed_entry[2], json) elif overshadowed_entry[0] == self.OVERSHADOWED_STATE_VARIABLE: - json_utils.add_variable_to_json(overshadowed_entry[2], json) + self.add_variable_to_json(overshadowed_entry[2], json) results.append(json) return results diff --git a/slither/detectors/shadowing/state.py b/slither/detectors/shadowing/state.py index 2ef792b55..41da711f3 100644 --- a/slither/detectors/shadowing/state.py +++ b/slither/detectors/shadowing/state.py @@ -3,7 +3,6 @@ Module detecting shadowing of state variables """ from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification -from slither.utils import json_utils class StateShadowing(AbstractDetector): @@ -84,7 +83,7 @@ contract DerivedContract is BaseContract{ var.source_mapping_str) json = self.generate_json_result(info) - json_utils.add_variables_to_json(all_variables, json) + self.add_variables_to_json(all_variables, json) results.append(json) diff --git a/slither/detectors/source/rtlo.py b/slither/detectors/source/rtlo.py index a3b34253d..7c4b78305 100644 --- a/slither/detectors/source/rtlo.py +++ b/slither/detectors/source/rtlo.py @@ -1,8 +1,6 @@ from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification import re -from slither.utils import json_utils - class RightToLeftOverride(AbstractDetector): """ @@ -75,10 +73,10 @@ contract Token info += f"\t- {pattern.findall(source_encoded)[0]}\n" json = self.generate_json_result(info) - json_utils.add_other_to_json("rtlo-character", - (filename, idx, len(self.RTLO_CHARACTER_ENCODED)), - json, - self.slither) + self.add_other_to_json("rtlo-character", + (filename, idx, len(self.RTLO_CHARACTER_ENCODED)), + json, + self.slither) results.append(json) # Advance the start index for the next iteration diff --git a/slither/detectors/statements/assembly.py b/slither/detectors/statements/assembly.py index 5fecabbaf..936794366 100644 --- a/slither/detectors/statements/assembly.py +++ b/slither/detectors/statements/assembly.py @@ -4,7 +4,6 @@ Module detecting usage of inline assembly from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification from slither.core.cfg.node import NodeType -from slither.utils import json_utils class Assembly(AbstractDetector): @@ -59,8 +58,8 @@ class Assembly(AbstractDetector): info += "\t- {}\n".format(node.source_mapping_str) json = self.generate_json_result(info) - json_utils.add_function_to_json(func, json) - json_utils.add_nodes_to_json(nodes, json) + self.add_function_to_json(func, json) + self.add_nodes_to_json(nodes, json) results.append(json) return results diff --git a/slither/detectors/statements/calls_in_loop.py b/slither/detectors/statements/calls_in_loop.py index 1b0dd2a75..092003c8f 100644 --- a/slither/detectors/statements/calls_in_loop.py +++ b/slither/detectors/statements/calls_in_loop.py @@ -5,7 +5,6 @@ from slither.detectors.abstract_detector import (AbstractDetector, DetectorClassification) from slither.slithir.operations import (HighLevelCall, LibraryCall, LowLevelCall, Send, Transfer) -from slither.utils import json_utils class MultipleCallsInLoop(AbstractDetector): @@ -92,7 +91,7 @@ If one of the destinations has a fallback function which reverts, `bad` will alw info = info.format(func.canonical_name, node.expression, node.source_mapping_str) json = self.generate_json_result(info) - json_utils.add_node_to_json(node, json) + self.add_node_to_json(node, json) results.append(json) return results diff --git a/slither/detectors/statements/controlled_delegatecall.py b/slither/detectors/statements/controlled_delegatecall.py index c07c2628f..455be0594 100644 --- a/slither/detectors/statements/controlled_delegatecall.py +++ b/slither/detectors/statements/controlled_delegatecall.py @@ -1,7 +1,6 @@ from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification from slither.slithir.operations import LowLevelCall from slither.analyses.data_dependency.data_dependency import is_tainted -from slither.utils import json_utils class ControlledDelegateCall(AbstractDetector): @@ -54,8 +53,8 @@ Bob calls `delegate` and delegates the execution to its malicious contract. As a node_info = func_info + '\t- {} ({})\n'.format(node.expression, node.source_mapping_str) json = self.generate_json_result(node_info) - json_utils.add_node_to_json(node, json) - json_utils.add_function_to_json(f, json) + self.add_node_to_json(node, json) + self.add_function_to_json(f, json) results.append(json) return results diff --git a/slither/detectors/statements/deprecated_calls.py b/slither/detectors/statements/deprecated_calls.py index 12cccd579..c18843125 100644 --- a/slither/detectors/statements/deprecated_calls.py +++ b/slither/detectors/statements/deprecated_calls.py @@ -3,7 +3,6 @@ Module detecting deprecated standards. """ from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification -from slither.utils import json_utils from slither.visitors.expression.export_values import ExportValues from slither.core.declarations.solidity_variables import SolidityVariableComposed, SolidityFunction from slither.core.cfg.node import NodeType @@ -163,9 +162,9 @@ contract ContractWithDeprecatedReferences { # Generate relevant JSON data for this deprecated standard. json = self.generate_json_result(info) if isinstance(source_object, StateVariableSolc) or isinstance(source_object, StateVariable): - json_utils.add_variable_to_json(source_object, json) + self.add_variable_to_json(source_object, json) else: - json_utils.add_nodes_to_json([source_object], json) + self.add_nodes_to_json([source_object], json) results.append(json) diff --git a/slither/detectors/statements/incorrect_strict_equality.py b/slither/detectors/statements/incorrect_strict_equality.py index ac2d39283..0ef6a5dea 100644 --- a/slither/detectors/statements/incorrect_strict_equality.py +++ b/slither/detectors/statements/incorrect_strict_equality.py @@ -3,7 +3,6 @@ """ -import itertools from slither.analyses.data_dependency.data_dependency import is_dependent_ssa from slither.core.declarations import Function from slither.detectors.abstract_detector import (AbstractDetector, @@ -15,8 +14,6 @@ from slither.core.solidity_types import MappingType, ElementaryType from slither.core.variables.state_variable import StateVariable from slither.core.declarations.solidity_variables import SolidityVariable, SolidityVariableComposed -from slither.slithir.variables import ReferenceVariable -from slither.utils import json_utils class IncorrectStrictEquality(AbstractDetector): @@ -125,8 +122,8 @@ contract Crowdsale{ node_info = func_info + f"\t- {str(node.expression)}\n" json = self.generate_json_result(node_info) - json_utils.add_node_to_json(node, json) - json_utils.add_function_to_json(f, json) + self.add_node_to_json(node, json) + self.add_function_to_json(f, json) results.append(json) return results diff --git a/slither/detectors/statements/too_many_digits.py b/slither/detectors/statements/too_many_digits.py index 29844100d..df9e21921 100644 --- a/slither/detectors/statements/too_many_digits.py +++ b/slither/detectors/statements/too_many_digits.py @@ -4,7 +4,6 @@ Module detecting numbers with too many digits. from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification from slither.slithir.variables import Constant -from slither.utils import json_utils class TooManyDigits(AbstractDetector): @@ -73,7 +72,7 @@ Use: # Add the result in result json = self.generate_json_result(node_info) - json_utils.add_node_to_json(node, json) + self.add_node_to_json(node, json) results.append(json) return results diff --git a/slither/detectors/statements/tx_origin.py b/slither/detectors/statements/tx_origin.py index 6d7cd10d5..3b4e662a7 100644 --- a/slither/detectors/statements/tx_origin.py +++ b/slither/detectors/statements/tx_origin.py @@ -3,7 +3,6 @@ Module detecting usage of `tx.origin` in a conditional node """ from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification -from slither.utils import json_utils class TxOrigin(AbstractDetector): @@ -74,7 +73,7 @@ Bob is the owner of `TxOrigin`. Bob calls Eve's contract. Eve's contract calls ` node.source_mapping_str) json = self.generate_json_result(info) - json_utils.add_node_to_json(node, json) + self.add_node_to_json(node, json) results.append(json) return results diff --git a/slither/detectors/variables/possible_const_state_variables.py b/slither/detectors/variables/possible_const_state_variables.py index 9e4a04cd9..e6c676c16 100644 --- a/slither/detectors/variables/possible_const_state_variables.py +++ b/slither/detectors/variables/possible_const_state_variables.py @@ -4,7 +4,6 @@ Module detecting state variables that could be declared as constant from slither.core.solidity_types.elementary_type import ElementaryType from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification -from slither.utils import json_utils from slither.visitors.expression.export_values import ExportValues from slither.core.declarations.solidity_variables import SolidityFunction from slither.core.variables.state_variable import StateVariable @@ -92,7 +91,7 @@ class ConstCandidateStateVars(AbstractDetector): info = "{} should be constant ({})\n".format(v.canonical_name, v.source_mapping_str) json = self.generate_json_result(info) - json_utils.add_variable_to_json(v, json) + self.add_variable_to_json(v, json) results.append(json) diff --git a/slither/detectors/variables/uninitialized_local_variables.py b/slither/detectors/variables/uninitialized_local_variables.py index 265727234..c767e7b2c 100644 --- a/slither/detectors/variables/uninitialized_local_variables.py +++ b/slither/detectors/variables/uninitialized_local_variables.py @@ -6,9 +6,6 @@ """ from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification -from slither.core.cfg.node import NodeType -from slither.utils import json_utils -from slither.visitors.expression.find_push import FindPush class UninitializedLocalVars(AbstractDetector): @@ -109,8 +106,8 @@ Bob calls `transfer`. As a result, the ethers are sent to the address 0x0 and ar json = self.generate_json_result(info) - json_utils.add_variable_to_json(uninitialized_local_variable, json) - json_utils.add_function_to_json(function, json) + self.add_variable_to_json(uninitialized_local_variable, json) + self.add_function_to_json(function, json) results.append(json) return results diff --git a/slither/detectors/variables/uninitialized_state_variables.py b/slither/detectors/variables/uninitialized_state_variables.py index 2250d9caf..86a9e09d3 100644 --- a/slither/detectors/variables/uninitialized_state_variables.py +++ b/slither/detectors/variables/uninitialized_state_variables.py @@ -10,13 +10,7 @@ """ from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification -from slither.core.variables.state_variable import StateVariable -from slither.slithir.variables import ReferenceVariable -from slither.slithir.operations.assignment import Assignment - -from slither.slithir.operations import (OperationWithLValue, Index, Member, - InternalCall, InternalDynamicCall, LibraryCall) -from slither.utils import json_utils +from slither.slithir.operations import InternalCall, LibraryCall class UninitializedStateVarsDetection(AbstractDetector): @@ -103,8 +97,8 @@ Initialize all the variables. If a variable is meant to be initialized to zero, source += [f.source_mapping for f in functions] json = self.generate_json_result(info) - json_utils.add_variable_to_json(variable, json) - json_utils.add_functions_to_json(functions, json) + self.add_variable_to_json(variable, json) + self.add_functions_to_json(functions, json) results.append(json) return results diff --git a/slither/detectors/variables/uninitialized_storage_variables.py b/slither/detectors/variables/uninitialized_storage_variables.py index 072300299..78f7b8343 100644 --- a/slither/detectors/variables/uninitialized_storage_variables.py +++ b/slither/detectors/variables/uninitialized_storage_variables.py @@ -6,9 +6,6 @@ """ from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification -from slither.utils import json_utils - -from slither.visitors.expression.find_push import FindPush class UninitializedStorageVars(AbstractDetector): @@ -109,10 +106,9 @@ Bob calls `func`. As a result, `owner` is override to 0. info = "{} in {} ({}) is a storage variable never initialiazed\n" info = info.format(var_name, function.canonical_name, uninitialized_storage_variable.source_mapping_str) - json = self.generate_json_result(info) - json_utils.add_variable_to_json(uninitialized_storage_variable, json) - json_utils.add_function_to_json(function, json) + self.add_variable_to_json(uninitialized_storage_variable, json) + self.add_function_to_json(function, json) results.append(json) return results diff --git a/slither/detectors/variables/unused_state_variables.py b/slither/detectors/variables/unused_state_variables.py index a815710c7..35fa66999 100644 --- a/slither/detectors/variables/unused_state_variables.py +++ b/slither/detectors/variables/unused_state_variables.py @@ -4,7 +4,6 @@ Module detecting unused state variables from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification from slither.core.solidity_types import ArrayType -from slither.utils import json_utils from slither.visitors.expression.export_values import ExportValues from slither.core.variables.state_variable import StateVariable from slither.formatters.variables.unused_state_variables import format @@ -65,10 +64,9 @@ class UnusedStateVars(AbstractDetector): var.source_mapping_str, c.name) - json = self.generate_json_result(info) - json_utils.add_variable_to_json(var, json) - json_utils.add_contract_to_json(c, json) + self.add_variable_to_json(var, json) + self.add_contract_to_json(c, json) results.append(json) return results From 1cd7dc80d56940a3c96363041c5333dd84012fbb Mon Sep 17 00:00:00 2001 From: Josselin Date: Mon, 4 Nov 2019 10:18:51 +0100 Subject: [PATCH 208/223] Add self.add_X_to_json to AbstractPrinter Refactor contract summary and human summary --- slither/__main__.py | 5 +- slither/printers/abstract_printer.py | 28 ++++++++- slither/printers/call/call_graph.py | 8 +-- slither/printers/functions/authorization.py | 3 +- slither/printers/functions/cfg.py | 4 +- slither/printers/inheritance/inheritance.py | 1 - .../printers/inheritance/inheritance_graph.py | 3 +- slither/printers/summary/contract.py | 57 +++++++++---------- slither/printers/summary/data_depenency.py | 2 +- slither/printers/summary/function.py | 3 +- slither/printers/summary/function_ids.py | 3 +- slither/printers/summary/human_summary.py | 8 ++- slither/printers/summary/modifier_calls.py | 3 +- slither/printers/summary/require_calls.py | 3 +- slither/printers/summary/slithir_ssa.py | 2 +- slither/printers/summary/variable_order.py | 3 +- 16 files changed, 74 insertions(+), 62 deletions(-) diff --git a/slither/__main__.py b/slither/__main__.py index a5f6dc4d6..f0e61894f 100644 --- a/slither/__main__.py +++ b/slither/__main__.py @@ -604,11 +604,12 @@ def main_impl(all_detector_classes, all_printer_classes): # Dont print the number of result for printers if number_contracts == 0: - logger.warn(red('No contract was analyzed')) + logger.warning(red('No contract was analyzed')) if printer_classes: logger.info('%s analyzed (%d contracts)', filename, number_contracts) else: - logger.info('%s analyzed (%d contracts with %d detectors), %d result(s) found', filename, number_contracts, len(detector_classes), len(results)) + logger.info('%s analyzed (%d contracts with %d detectors), %d result(s) found', filename, + number_contracts, len(detector_classes), len(results_detectors)) if args.ignore_return_value: return diff --git a/slither/printers/abstract_printer.py b/slither/printers/abstract_printer.py index 5f9cbd6c9..3c7331138 100644 --- a/slither/printers/abstract_printer.py +++ b/slither/printers/abstract_printer.py @@ -33,12 +33,38 @@ class AbstractPrinter(metaclass=abc.ABCMeta): self.logger.info(info) - def generate_json_result(self, info, additional_fields={}): + def generate_json_result(self, info, additional_fields=None): + if additional_fields is None: + additional_fields = {} d = json_utils.generate_json_result(info, additional_fields) d['printer'] = self.ARGUMENT return d + @staticmethod + def add_contract_to_json(e, d, additional_fields=None): + json_utils.add_contract_to_json(e, d, additional_fields=additional_fields) + + @staticmethod + def add_function_to_json(e, d, additional_fields=None): + json_utils.add_function_to_json(e, d, additional_fields=additional_fields) + + @staticmethod + def add_functions_to_json(e, d, additional_fields=None): + json_utils.add_functions_to_json(e, d, additional_fields=additional_fields) + + @staticmethod + def add_file_to_json(e, content, d, additional_fields=None): + json_utils.add_file_to_json(e, content, d, additional_fields) + + @staticmethod + def add_pretty_table_to_json(e, content, d, additional_fields=None): + json_utils.add_pretty_table_to_json(e, content, d, additional_fields) + + @staticmethod + def add_other_to_json(name, source_mapping, d, slither, additional_fields=None): + json_utils.add_other_to_json(name, source_mapping, d, slither, additional_fields) + @abc.abstractmethod def output(self, filename): """TODO Documentation""" diff --git a/slither/printers/call/call_graph.py b/slither/printers/call/call_graph.py index 285635163..2f224ece0 100644 --- a/slither/printers/call/call_graph.py +++ b/slither/printers/call/call_graph.py @@ -9,14 +9,8 @@ from collections import defaultdict from slither.printers.abstract_printer import AbstractPrinter from slither.core.declarations.solidity_variables import SolidityFunction from slither.core.declarations.function import Function -from slither.core.declarations.contract import Contract -from slither.core.expressions.member_access import MemberAccess -from slither.core.expressions.identifier import Identifier from slither.core.variables.variable import Variable -from slither.core.solidity_types.user_defined_type import UserDefinedType -# return unique id for contract to use as subgraph name -from slither.utils import json_utils def _contract_subgraph(contract): @@ -184,7 +178,7 @@ class PrinterCallGraph(AbstractPrinter): self.info(info) json = self.generate_json_result(info) for filename, content in results: - json_utils.add_file_to_json(filename, content, json) + self.add_file_to_json(filename, content, json) return json diff --git a/slither/printers/functions/authorization.py b/slither/printers/functions/authorization.py index e934c28d7..72fc532b3 100644 --- a/slither/printers/functions/authorization.py +++ b/slither/printers/functions/authorization.py @@ -5,7 +5,6 @@ from prettytable import PrettyTable from slither.printers.abstract_printer import AbstractPrinter from slither.core.declarations.function import Function -from slither.utils import json_utils class PrinterWrittenVariablesAndAuthorization(AbstractPrinter): @@ -51,6 +50,6 @@ class PrinterWrittenVariablesAndAuthorization(AbstractPrinter): self.info(txt) json = self.generate_json_result(txt) for name, table in all_tables: - json_utils.add_pretty_table_to_json(table, name, json) + self.add_pretty_table_to_json(table, name, json) return json \ No newline at end of file diff --git a/slither/printers/functions/cfg.py b/slither/printers/functions/cfg.py index 09a76a1c6..191d63b5c 100644 --- a/slither/printers/functions/cfg.py +++ b/slither/printers/functions/cfg.py @@ -2,8 +2,6 @@ """ from slither.printers.abstract_printer import AbstractPrinter -from slither.core.declarations.function import Function -from slither.utils import json_utils class CFG(AbstractPrinter): @@ -35,5 +33,5 @@ class CFG(AbstractPrinter): json = self.generate_json_result(info) for filename, content in all_files: - json_utils.add_file_to_json(filename, content, json) + self.add_file_to_json(filename, content, json) return json \ No newline at end of file diff --git a/slither/printers/inheritance/inheritance.py b/slither/printers/inheritance/inheritance.py index d151b6486..f3b970dfc 100644 --- a/slither/printers/inheritance/inheritance.py +++ b/slither/printers/inheritance/inheritance.py @@ -5,7 +5,6 @@ """ from slither.printers.abstract_printer import AbstractPrinter -from slither.utils import json_utils from slither.utils.colors import blue, green diff --git a/slither/printers/inheritance/inheritance_graph.py b/slither/printers/inheritance/inheritance_graph.py index 529c4bdd9..52f4f32e2 100644 --- a/slither/printers/inheritance/inheritance_graph.py +++ b/slither/printers/inheritance/inheritance_graph.py @@ -9,7 +9,6 @@ from slither.core.declarations.contract import Contract from slither.core.solidity_types.user_defined_type import UserDefinedType from slither.printers.abstract_printer import AbstractPrinter -from slither.utils import json_utils from slither.utils.inheritance_analysis import (detect_c3_function_shadowing, detect_state_variable_shadowing) @@ -174,6 +173,6 @@ class PrinterInheritanceGraph(AbstractPrinter): f.write(content) json = self.generate_json_result(info) - json_utils.add_file_to_json(filename, content, json) + self.add_file_to_json(filename, content, json) return json \ No newline at end of file diff --git a/slither/printers/summary/contract.py b/slither/printers/summary/contract.py index ef4d13d6a..df7742281 100644 --- a/slither/printers/summary/contract.py +++ b/slither/printers/summary/contract.py @@ -3,11 +3,10 @@ """ import collections from slither.printers.abstract_printer import AbstractPrinter -from slither.utils import json_utils from slither.utils.colors import blue, green, magenta -class ContractSummary(AbstractPrinter): +class ContractSummary(AbstractPrinter): ARGUMENT = 'contract-summary' HELP = 'Print a summary of the contracts' @@ -21,42 +20,42 @@ class ContractSummary(AbstractPrinter): """ txt = "" - result = {} + + all_contracts = [] for c in self.contracts: - (name, _inheritance, _var, func_summaries, _modif_summaries) = c.get_summary(False) - txt += blue("\n+ Contract %s\n"%name) - result[name] = {} - # (c_name, f_name, visi, _, _, _, _, _) in func_summaries - public = [(elem[0], (elem[1], elem[2]) ) for elem in func_summaries] + txt += blue("\n+ Contract %s\n" % c.name) + additional_fields = {"elements": []} + # Order the function with + # contract_declarer -> list_functions + public = [(f.contract_declarer.name, f) for f in c.functions if (not f.is_shadowed)] collect = collections.defaultdict(list) - for a,b in public: + for a, b in public: collect[a].append(b) public = list(collect.items()) for contract, functions in public: txt += blue(" - From {}\n".format(contract)) - result[name]['from'] = str(contract) - functions = sorted(functions) - result[name]['functions'] = {} - result[name]['functions']['visible'] = [] - result[name]['functions']['invisible'] = [] - result[name]['functions']['others'] = [] - for (function, visi) in functions: - if visi in ['external', 'public']: - result[name]['functions']['visible'].append({'function': function, 'visi': visi}) - txt += green(" - {} ({})\n".format(function, visi)) - for (function, visi) in functions: - if visi in ['internal', 'private']: - result[name]['functions']['invisible'].append({'function': function, 'visi': visi}) - txt += magenta(" - {} ({})\n".format(function, visi)) - for (function, visi) in functions: - if visi not in ['external', 'public', 'internal', 'private']: - result[name]['functions']['others'].append({'function': function, 'visi': visi}) - txt += " - {}  ({})\n".format(function, visi) + + functions = sorted(functions, key=lambda f: f.full_name) + + for function in functions: + if function.visibility in ['external', 'public']: + txt += green(" - {} ({})\n".format(function, function.visibility)) + if function.visibility in ['internal', 'private']: + txt += magenta(" - {} ({})\n".format(function, function.visibility)) + if function.visibility not in ['external', 'public', 'internal', 'private']: + txt += " - {}  ({})\n".format(function, function.visibility) + + self.add_function_to_json(function, additional_fields, additional_fields={"visibility": + function.visibility}) + + all_contracts.append((c, additional_fields)) self.info(txt) - json = self.generate_json_result(txt, additional_fields=result) + json = self.generate_json_result(txt) + for contract, additional_fields in all_contracts: + self.add_contract_to_json(contract, json, additional_fields=additional_fields) - return json \ No newline at end of file + return json diff --git a/slither/printers/summary/data_depenency.py b/slither/printers/summary/data_depenency.py index e30814f81..cbd36fcdb 100644 --- a/slither/printers/summary/data_depenency.py +++ b/slither/printers/summary/data_depenency.py @@ -53,6 +53,6 @@ class DataDependency(AbstractPrinter): json = self.generate_json_result(all_txt) for name, table in all_tables: - json_utils.add_pretty_table_to_json(table, name, json) + self.add_pretty_table_to_json(table, name, json) return json diff --git a/slither/printers/summary/function.py b/slither/printers/summary/function.py index b9659cf03..e9a71a965 100644 --- a/slither/printers/summary/function.py +++ b/slither/printers/summary/function.py @@ -4,7 +4,6 @@ from prettytable import PrettyTable from slither.printers.abstract_printer import AbstractPrinter -from slither.utils import json_utils class FunctionSummary(AbstractPrinter): @@ -73,6 +72,6 @@ class FunctionSummary(AbstractPrinter): json = self.generate_json_result(all_txt) for name, table in all_tables: - json_utils.add_pretty_table_to_json(table, name, json) + self.add_pretty_table_to_json(table, name, json) return json diff --git a/slither/printers/summary/function_ids.py b/slither/printers/summary/function_ids.py index 44bf9d7c6..5aee6529c 100644 --- a/slither/printers/summary/function_ids.py +++ b/slither/printers/summary/function_ids.py @@ -4,7 +4,6 @@ from prettytable import PrettyTable from slither.printers.abstract_printer import AbstractPrinter -from slither.utils import json_utils from slither.utils.function import get_function_id class FunctionIds(AbstractPrinter): @@ -40,6 +39,6 @@ class FunctionIds(AbstractPrinter): json = self.generate_json_result(txt) for name, table in all_tables: - json_utils.add_pretty_table_to_json(table, name, json) + self.add_pretty_table_to_json(table, name, json) return json \ No newline at end of file diff --git a/slither/printers/summary/human_summary.py b/slither/printers/summary/human_summary.py index fcd635365..156e353fa 100644 --- a/slither/printers/summary/human_summary.py +++ b/slither/printers/summary/human_summary.py @@ -4,7 +4,6 @@ Module printing summary of the contract import logging from slither.printers.abstract_printer import AbstractPrinter -from slither.utils import json_utils from slither.utils.code_complexity import compute_cyclomatic_complexity from slither.utils.colors import green, red, yellow from slither.utils.standard_libraries import is_standard_library @@ -197,7 +196,9 @@ class PrinterHumanSummary(AbstractPrinter): txt += self._compilation_type() results = { - 'contracts': [], + 'contracts': { + "elements": [] + }, 'number_lines': 0, 'number_lines_in_dependencies': 0, 'standard_libraries': [], @@ -260,7 +261,8 @@ class PrinterHumanSummary(AbstractPrinter): else: contract_d['erc20_can_mint'] = False contract_d['erc20_race_condition_mitigated'] = race_condition_mitigated - results['contracts'].append(contract_d) + + self.add_contract_to_json(contract, results['contracts'], additional_fields=contract_d) json = self.generate_json_result(txt, additional_fields=results) diff --git a/slither/printers/summary/modifier_calls.py b/slither/printers/summary/modifier_calls.py index 858a813ff..fbc62c90d 100644 --- a/slither/printers/summary/modifier_calls.py +++ b/slither/printers/summary/modifier_calls.py @@ -5,7 +5,6 @@ from prettytable import PrettyTable from slither.core.declarations import Function from slither.printers.abstract_printer import AbstractPrinter -from slither.utils import json_utils class Modifiers(AbstractPrinter): @@ -43,6 +42,6 @@ class Modifiers(AbstractPrinter): json = self.generate_json_result(all_txt) for name, table in all_tables: - json_utils.add_pretty_table_to_json(table, name, json) + self.add_pretty_table_to_json(table, name, json) return json \ No newline at end of file diff --git a/slither/printers/summary/require_calls.py b/slither/printers/summary/require_calls.py index ab2874d67..51c67284d 100644 --- a/slither/printers/summary/require_calls.py +++ b/slither/printers/summary/require_calls.py @@ -6,7 +6,6 @@ from prettytable import PrettyTable from slither.core.declarations import SolidityFunction from slither.printers.abstract_printer import AbstractPrinter from slither.slithir.operations import SolidityCall -from slither.utils import json_utils require_or_assert = [SolidityFunction("assert(bool)"), SolidityFunction("require(bool)"), @@ -48,6 +47,6 @@ class RequireOrAssert(AbstractPrinter): json = self.generate_json_result(all_txt) for name, table in all_tables: - json_utils.add_pretty_table_to_json(table, name, json) + self.add_pretty_table_to_json(table, name, json) return json diff --git a/slither/printers/summary/slithir_ssa.py b/slither/printers/summary/slithir_ssa.py index c97a291fa..37acd457e 100644 --- a/slither/printers/summary/slithir_ssa.py +++ b/slither/printers/summary/slithir_ssa.py @@ -3,7 +3,7 @@ """ from slither.printers.abstract_printer import AbstractPrinter -from slither.utils.colors import blue, green, magenta + class PrinterSlithIRSSA(AbstractPrinter): diff --git a/slither/printers/summary/variable_order.py b/slither/printers/summary/variable_order.py index d0debe60a..ffee1f940 100644 --- a/slither/printers/summary/variable_order.py +++ b/slither/printers/summary/variable_order.py @@ -4,7 +4,6 @@ from prettytable import PrettyTable from slither.printers.abstract_printer import AbstractPrinter -from slither.utils import json_utils class VariableOrder(AbstractPrinter): @@ -39,6 +38,6 @@ class VariableOrder(AbstractPrinter): json = self.generate_json_result(txt) for name, table in all_tables: - json_utils.add_pretty_table_to_json(table, name, json) + self.add_pretty_table_to_json(table, name, json) return json \ No newline at end of file From ec00646cb30b2f4d50419fbb0b729a90c915daa1 Mon Sep 17 00:00:00 2001 From: Josselin Date: Mon, 4 Nov 2019 10:40:31 +0100 Subject: [PATCH 209/223] Fix minor --- slither/__main__.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/slither/__main__.py b/slither/__main__.py index f0e61894f..5f9a68158 100644 --- a/slither/__main__.py +++ b/slither/__main__.py @@ -543,6 +543,8 @@ def main_impl(all_detector_classes, all_printer_classes): crytic_compile_error.propagate = False crytic_compile_error.setLevel(logging.INFO) + results_detectors = [] + results_printers = [] try: filename = args.filename @@ -553,8 +555,7 @@ def main_impl(all_detector_classes, all_printer_classes): if not filenames: filenames = globbed_filenames number_contracts = 0 - results_detectors = [] - results_printers = [] + slither_instances = [] if args.splitted: (slither_instance, results_detectors, results_printers, number_contracts) = process_from_asts(filenames, args, detector_classes, printer_classes) @@ -638,7 +639,7 @@ def main_impl(all_detector_classes, all_printer_classes): if output_error: sys.exit(-1) else: - exit(len(results_detectors)) + exit(results_detectors) if __name__ == '__main__': From e364ba208ead091bfb0fab3e0a0d684b14d8f5b6 Mon Sep 17 00:00:00 2001 From: Josselin Date: Mon, 4 Nov 2019 13:24:21 +0100 Subject: [PATCH 210/223] API break: generate_json_result takes a list as input, instead of a str The list can contains str, or any elements that can be converted to a str with source mapping Ex: Variable, Contract, Event, Function, .. generate_json_result will automatically add the elements to the json. As a result, detectors only need to add the elements to the info list, and do not need to add the element to the json. AbstractDetectors has a STANDARD_JSON parameter, if set to False, generate_json_result will not add the elements to the json --- slither/__main__.py | 5 + slither/core/declarations/pragma_directive.py | 4 + slither/core/slither_core.py | 6 + slither/core/source_mapping/source_mapping.py | 20 +- slither/core/variables/local_variable.py | 2 +- slither/detectors/abstract_detector.py | 7 +- .../detectors/attributes/const_functions.py | 16 +- .../detectors/attributes/constant_pragma.py | 10 +- .../detectors/attributes/incorrect_solc.py | 4 +- slither/detectors/attributes/locked_ether.py | 14 +- .../erc/incorrect_erc20_interface.py | 9 +- .../erc/incorrect_erc721_interface.py | 7 +- .../erc/unindexed_event_parameters.py | 5 +- slither/detectors/examples/backdoor.py | 6 +- slither/detectors/functions/arbitrary_send.py | 11 +- .../detectors/functions/external_function.py | 13 +- slither/detectors/functions/suicidal.py | 6 +- .../naming_convention/naming_convention.py | 34 +- .../detectors/operations/block_timestamp.py | 12 +- .../detectors/operations/low_level_calls.py | 9 +- .../operations/unused_return_values.py | 10 +- .../detectors/operations/void_constructor.py | 8 +- .../detectors/reentrancy/reentrancy_benign.py | 19 +- .../detectors/reentrancy/reentrancy_eth.py | 18 +- .../reentrancy_read_before_write.py | 13 +- slither/detectors/shadowing/abstract.py | 8 +- .../detectors/shadowing/builtin_symbols.py | 29 +- slither/detectors/shadowing/local.py | 34 +- slither/detectors/shadowing/state.py | 8 +- slither/detectors/source/rtlo.py | 1 + slither/detectors/statements/assembly.py | 7 +- slither/detectors/statements/calls_in_loop.py | 5 +- .../statements/controlled_delegatecall.py | 9 +- .../detectors/statements/deprecated_calls.py | 12 +- .../statements/incorrect_strict_equality.py | 7 +- .../detectors/statements/too_many_digits.py | 7 +- slither/detectors/statements/tx_origin.py | 7 +- .../possible_const_state_variables.py | 5 +- .../uninitialized_local_variables.py | 10 +- .../uninitialized_state_variables.py | 13 +- .../uninitialized_storage_variables.py | 8 +- .../variables/unused_state_variables.py | 7 +- slither/slither.py | 2 + slither/utils/json_utils.py | 75 +- .../arbitrary_send-0.5.1.arbitrary-send.json | 22 +- .../arbitrary_send-0.5.1.arbitrary-send.txt | 4 +- .../arbitrary_send.arbitrary-send.json | 22 +- .../arbitrary_send.arbitrary-send.txt | 4 +- tests/expected_json/backdoor.backdoor.json | 11 +- tests/expected_json/backdoor.backdoor.txt | 6 +- tests/expected_json/backdoor.suicidal.json | 11 +- tests/expected_json/backdoor.suicidal.txt | 4 +- ...onst_state_variables.constable-states.json | 66 +- ...const_state_variables.constable-states.txt | 16 +- .../constant-0.5.1.constant-function.json | 11 +- .../constant-0.5.1.constant-function.txt | 4 +- .../constant.constant-function.json | 33 +- .../constant.constant-function.txt | 8 +- ..._delegatecall.controlled-delegatecall.json | 178 +++-- ...d_delegatecall.controlled-delegatecall.txt | 8 +- ...deprecated_calls.deprecated-standards.json | 88 +- .../deprecated_calls.deprecated-standards.txt | 20 +- .../erc20_indexed.erc20-indexed.json | 44 +- .../erc20_indexed.erc20-indexed.txt | 12 +- .../external_function.external-function.json | 55 +- ...incorrect_equality.incorrect-equality.json | 756 +++++++++--------- .../incorrect_equality.incorrect-equality.txt | 28 +- ...rrect_erc20_interface.erc20-interface.json | 216 ++++- ...orrect_erc20_interface.erc20-interface.txt | 16 +- ...ect_erc721_interface.erc721-interface.json | 390 +++++++-- ...rect_erc721_interface.erc721-interface.txt | 24 +- ...line_assembly_contract-0.5.1.assembly.json | 11 +- ...nline_assembly_contract-0.5.1.assembly.txt | 8 +- .../inline_assembly_contract.assembly.json | 11 +- .../inline_assembly_contract.assembly.txt | 8 +- ...nline_assembly_library-0.5.1.assembly.json | 22 +- ...inline_assembly_library-0.5.1.assembly.txt | 12 +- .../inline_assembly_library.assembly.json | 22 +- .../inline_assembly_library.assembly.txt | 12 +- .../locked_ether-0.5.1.locked-ether.json | 11 +- .../locked_ether-0.5.1.locked-ether.txt | 8 +- .../locked_ether.locked-ether.json | 11 +- .../locked_ether.locked-ether.txt | 8 +- .../low_level_calls.low-level-calls.json | 11 +- .../low_level_calls.low-level-calls.txt | 6 +- .../multiple_calls_in_loop.calls-loop.json | 68 +- .../multiple_calls_in_loop.calls-loop.txt | 8 +- .../naming_convention.naming-convention.json | 132 +-- .../naming_convention.naming-convention.txt | 28 +- .../old_solc.sol.json.solc-version.json | 11 +- .../old_solc.sol.json.solc-version.txt | 6 +- tests/expected_json/pragma.0.4.24.pragma.json | 11 +- tests/expected_json/pragma.0.4.24.pragma.txt | 8 +- .../reentrancy-0.5.1.reentrancy-eth.json | 22 +- .../reentrancy-0.5.1.reentrancy-eth.txt | 8 +- .../reentrancy.reentrancy-eth.json | 22 +- .../reentrancy.reentrancy-eth.txt | 8 +- .../right_to_left_override.rtlo.json | 11 +- .../right_to_left_override.rtlo.txt | 4 +- ...shadowing_abstract.shadowing-abstract.json | 11 +- .../shadowing_abstract.shadowing-abstract.txt | 4 +- ...ing_builtin_symbols.shadowing-builtin.json | 143 ++-- ...wing_builtin_symbols.shadowing-builtin.txt | 30 +- ...dowing_local_variable.shadowing-local.json | 55 +- ...adowing_local_variable.shadowing-local.txt | 28 +- ...dowing_state_variable.shadowing-state.json | 11 +- ...adowing_state_variable.shadowing-state.txt | 4 +- .../solc_version_incorrect.solc-version.json | 22 +- .../solc_version_incorrect.solc-version.txt | 8 +- ...on_incorrect_05.ast.json.solc-version.json | 22 +- ...ion_incorrect_05.ast.json.solc-version.txt | 8 +- tests/expected_json/timestamp.timestamp.json | 33 +- tests/expected_json/timestamp.timestamp.txt | 4 +- .../too_many_digits.too-many-digits.json | 463 ++++++++++- .../too_many_digits.too-many-digits.txt | 22 +- .../tx_origin-0.5.1.tx-origin.json | 152 +++- .../tx_origin-0.5.1.tx-origin.txt | 8 +- tests/expected_json/tx_origin.tx-origin.json | 152 +++- tests/expected_json/tx_origin.tx-origin.txt | 8 +- ...ked_lowlevel-0.5.1.unchecked-lowlevel.json | 113 +-- ...cked_lowlevel-0.5.1.unchecked-lowlevel.txt | 6 +- ...unchecked_lowlevel.unchecked-lowlevel.json | 111 +-- .../unchecked_lowlevel.unchecked-lowlevel.txt | 6 +- .../unchecked_send-0.5.1.unchecked-send.json | 127 +-- .../unchecked_send-0.5.1.unchecked-send.txt | 6 +- ...initialized-0.5.1.uninitialized-state.json | 44 +- ...ninitialized-0.5.1.uninitialized-state.txt | 12 +- .../uninitialized.uninitialized-state.json | 44 +- .../uninitialized.uninitialized-state.txt | 12 +- ...ed_local_variable.uninitialized-local.json | 62 +- ...zed_local_variable.uninitialized-local.txt | 6 +- ...storage_pointer.uninitialized-storage.json | 68 +- ..._storage_pointer.uninitialized-storage.txt | 6 +- .../unused_return.unused-return.json | 168 ++-- .../unused_return.unused-return.txt | 8 +- .../unused_state.unused-state.json | 44 +- .../unused_state.unused-state.txt | 12 +- tests/expected_json/void-cst.void-cst.json | 11 +- tests/expected_json/void-cst.void-cst.txt | 6 +- 139 files changed, 3160 insertions(+), 1987 deletions(-) diff --git a/slither/__main__.py b/slither/__main__.py index 5f9a68158..699134c58 100644 --- a/slither/__main__.py +++ b/slither/__main__.py @@ -331,6 +331,11 @@ def parse_args(detector_classes, printer_classes): action='store', default=defaults_flag_in_config['json-types']) + group_misc.add_argument('--markdown-root', + help='URL for markdown generation', + action='store', + default="") + group_misc.add_argument('--disable-color', help='Disable output colorization', action='store_true', diff --git a/slither/core/declarations/pragma_directive.py b/slither/core/declarations/pragma_directive.py index 1747b9229..1b1cd4756 100644 --- a/slither/core/declarations/pragma_directive.py +++ b/slither/core/declarations/pragma_directive.py @@ -17,5 +17,9 @@ class Pragma(SourceMapping): def version(self): return ''.join(self.directive[1:]) + @property + def name(self): + return self.version + def __str__(self): return 'pragma '+''.join(self.directive) diff --git a/slither/core/slither_core.py b/slither/core/slither_core.py index 6442b2443..ec4572b4d 100644 --- a/slither/core/slither_core.py +++ b/slither/core/slither_core.py @@ -37,6 +37,8 @@ class Slither(Context): self._generate_patches = False + self._markdown_root = "" + ################################################################################### ################################################################################### # region Source code @@ -68,6 +70,10 @@ class Slither(Context): with open(path, encoding='utf8', newline='') as f: self.source_code[path] = f.read() + @property + def markdown_root(self): + return self._markdown_root + # endregion ################################################################################### ################################################################################### diff --git a/slither/core/source_mapping/source_mapping.py b/slither/core/source_mapping/source_mapping.py index 564b2f0e1..839d74a8f 100644 --- a/slither/core/source_mapping/source_mapping.py +++ b/slither/core/source_mapping/source_mapping.py @@ -132,16 +132,22 @@ class SourceMapping(Context): else: self._source_mapping = self._convert_source_mapping(offset, slither) - - @property - def source_mapping_str(self): - + def _get_lines_str(self, line_descr=""): lines = self.source_mapping.get('lines', None) if not lines: lines = '' elif len(lines) == 1: - lines = '#{}'.format(lines[0]) + lines = '#{}{}'.format(line_descr, lines[0]) else: - lines = '#{}-{}'.format(lines[0], lines[-1]) - return '{}{}'.format(self.source_mapping['filename_short'], lines) + lines = '#{}{}-{}{}'.format(line_descr, lines[0], line_descr, lines[-1]) + return lines + + def source_mapping_to_markdown(self, markdown_root): + lines = self._get_lines_str(line_descr="L") + return f'{markdown_root}{self.source_mapping["filename_relative"]}{lines}' + + @property + def source_mapping_str(self): + lines = self._get_lines_str() + return f'{self.source_mapping["filename_short"]}{lines}' diff --git a/slither/core/variables/local_variable.py b/slither/core/variables/local_variable.py index 39e237271..8b353d530 100644 --- a/slither/core/variables/local_variable.py +++ b/slither/core/variables/local_variable.py @@ -52,6 +52,6 @@ class LocalVariable(ChildFunction, Variable): @property def canonical_name(self): - return self.name + return '{}.{}'.format(self.function.canonical_name, self.name) diff --git a/slither/detectors/abstract_detector.py b/slither/detectors/abstract_detector.py index fb9aca05d..06a6ae8fa 100644 --- a/slither/detectors/abstract_detector.py +++ b/slither/detectors/abstract_detector.py @@ -49,6 +49,8 @@ class AbstractDetector(metaclass=abc.ABCMeta): WIKI_EXPLOIT_SCENARIO = '' WIKI_RECOMMENDATION = '' + STANDARD_JSON = True + def __init__(self, slither, logger): self.slither = slither self.contracts = slither.contracts @@ -169,7 +171,10 @@ class AbstractDetector(metaclass=abc.ABCMeta): return classification_colors[self.IMPACT] def generate_json_result(self, info, additional_fields=None): - d = json_utils.generate_json_result(info, additional_fields) + d = json_utils.generate_json_result(info, + additional_fields, + standard_format=self.STANDARD_JSON, + markdown_root=self.slither.markdown_root) d['check'] = self.ARGUMENT d['impact'] = classification_txt[self.IMPACT] diff --git a/slither/detectors/attributes/const_functions.py b/slither/detectors/attributes/const_functions.py index 7d5d492f4..99247b91b 100644 --- a/slither/detectors/attributes/const_functions.py +++ b/slither/detectors/attributes/const_functions.py @@ -57,23 +57,23 @@ All the calls to `get` revert, breaking Bob's smart contract execution.''' if f.view or f.pure: if f.contains_assembly: attr = 'view' if f.view else 'pure' - info = '{} ({}) is declared {} but contains assembly code\n' - info = info.format(f.canonical_name, f.source_mapping_str, attr) + + info = [f, f' is declared {attr} but contains assembly code\n'] json = self.generate_json_result(info, {'contains_assembly': True}) - self.add_function_to_json(f, json) + results.append(json) variables_written = f.all_state_variables_written() if variables_written: attr = 'view' if f.view else 'pure' - info = '{} ({}) is declared {} but changes state variables:\n' - info = info.format(f.canonical_name, f.source_mapping_str, attr) + + info = [f, f' is declared {attr} but changes state variables:\n'] + for variable_written in variables_written: - info += '\t- {}\n'.format(variable_written.canonical_name) + info += ['\t- ', variable_written, '\n'] json = self.generate_json_result(info, {'contains_assembly': False}) - self.add_function_to_json(f, json) - self.add_variables_to_json(variables_written, json) + results.append(json) return results diff --git a/slither/detectors/attributes/constant_pragma.py b/slither/detectors/attributes/constant_pragma.py index 0c2e54bca..d931d6a3d 100644 --- a/slither/detectors/attributes/constant_pragma.py +++ b/slither/detectors/attributes/constant_pragma.py @@ -30,16 +30,14 @@ class ConstantPragma(AbstractDetector): versions = sorted(list(set(versions))) if len(versions) > 1: - info = "Different versions of Solidity is used in {}:\n".format(self.filename) - info += "\t- Version used: {}\n".format([str(v) for v in versions]) + info = [f"Different versions of Solidity is used in {self.filename}:\n"] + info += [f"\t- Version used: {[str(v) for v in versions]}\n"] + for p in pragma: - info += "\t- {} declares {}\n".format(p.source_mapping_str, str(p)) + info += ["\t- ", p, "\n"] json = self.generate_json_result(info) - # Add each pragma to our elements - for p in pragma: - self.add_pragma_to_json(p, json) results.append(json) return results diff --git a/slither/detectors/attributes/incorrect_solc.py b/slither/detectors/attributes/incorrect_solc.py index 17dcd5204..95b967750 100644 --- a/slither/detectors/attributes/incorrect_solc.py +++ b/slither/detectors/attributes/incorrect_solc.py @@ -100,10 +100,10 @@ Use Solidity 0.4.25 or 0.5.3. Consider using the latest version of Solidity for # If we found any disallowed pragmas, we output our findings. if disallowed_pragmas: for (reason, p) in disallowed_pragmas: - info = f"Pragma version \"{p.version}\" {reason} ({p.source_mapping_str})\n" + info = ["Pragma version", p, f" {reason}\n"] json = self.generate_json_result(info) - self.add_pragma_to_json(p, json) + results.append(json) return results diff --git a/slither/detectors/attributes/locked_ether.py b/slither/detectors/attributes/locked_ether.py index 2a4e1d1c3..3de56c00c 100644 --- a/slither/detectors/attributes/locked_ether.py +++ b/slither/detectors/attributes/locked_ether.py @@ -74,18 +74,14 @@ Every ether sent to `Locked` will be lost.''' funcs_payable = [function for function in contract.functions if function.payable] if funcs_payable: if self.do_no_send_ether(contract): - txt = "Contract locking ether found in {}:\n".format(self.filename) - txt += "\tContract {} has payable functions:\n".format(contract.name) + info = [f"Contract locking ether found in {self.filename}:\n"] + info += ["\tContract ", contract, " has payable functions:\n"] for function in funcs_payable: - txt += "\t - {} ({})\n".format(function.name, function.source_mapping_str) - txt += "\tBut does not have a function to withdraw the ether\n" - info = txt.format(self.filename, - contract.name, - [f.name for f in funcs_payable]) + info += [f"\t - ", function, "\n"] + info += "\tBut does not have a function to withdraw the ether\n" json = self.generate_json_result(info) - self.add_contract_to_json(contract, json) - self.add_functions_to_json(funcs_payable, json) + results.append(json) return results diff --git a/slither/detectors/erc/incorrect_erc20_interface.py b/slither/detectors/erc/incorrect_erc20_interface.py index c2c0a4112..a9aa4ad77 100644 --- a/slither/detectors/erc/incorrect_erc20_interface.py +++ b/slither/detectors/erc/incorrect_erc20_interface.py @@ -87,12 +87,9 @@ contract Token{ functions = IncorrectERC20InterfaceDetection.detect_incorrect_erc20_interface(c) if functions: for function in functions: - info = "{} ({}) has incorrect ERC20 function interface: {} ({})\n".format(c.name, - c.source_mapping_str, - function.full_name, - function.source_mapping_str) - json = self.generate_json_result(info) - self.add_function_to_json(function, json) + info = [c, " has incorrect ERC20 function interface:", function, "\n"] + json = self.generate_json_result(info) + results.append(json) return results diff --git a/slither/detectors/erc/incorrect_erc721_interface.py b/slither/detectors/erc/incorrect_erc721_interface.py index bff88413c..bce1695b1 100644 --- a/slither/detectors/erc/incorrect_erc721_interface.py +++ b/slither/detectors/erc/incorrect_erc721_interface.py @@ -86,12 +86,9 @@ contract Token{ functions = IncorrectERC721InterfaceDetection.detect_incorrect_erc721_interface(c) if functions: for function in functions: - info = "{} ({}) has incorrect ERC721 function interface: {} ({})\n".format(c.name, - c.source_mapping_str, - function.full_name, - function.source_mapping_str) + info = [c, " has incorrect ERC721 function interface:", function, "\n"] json = self.generate_json_result(info) - self.add_function_to_json(function, json) + results.append(json) return results diff --git a/slither/detectors/erc/unindexed_event_parameters.py b/slither/detectors/erc/unindexed_event_parameters.py index 55ab15e25..1e382da59 100644 --- a/slither/detectors/erc/unindexed_event_parameters.py +++ b/slither/detectors/erc/unindexed_event_parameters.py @@ -32,6 +32,8 @@ In this case, Transfer and Approval events should have the 'indexed' keyword on WIKI_RECOMMENDATION = 'Add the `indexed` keyword to event parameters which should include it, according to the ERC20 specification.' + STANDARD_JSON = False + @staticmethod def detect_erc20_unindexed_event_params(contract): """ @@ -71,10 +73,11 @@ In this case, Transfer and Approval events should have the 'indexed' keyword on # Add each problematic event definition to our result list for (event, parameter) in unindexed_params: - info = "ERC20 event {}.{} ({}) does not index parameter '{}'\n".format(c.name, event.name, event.source_mapping_str, parameter.name) + info = ["ERC20 event ", event, f"does not index parameter {parameter}\n"] # Add the events to the JSON (note: we do not add the params/vars as they have no source mapping). json = self.generate_json_result(info) + self.add_event_to_json(event, json, { "parameter_name": parameter.name }) diff --git a/slither/detectors/examples/backdoor.py b/slither/detectors/examples/backdoor.py index bbc60a8b3..d9f00979e 100644 --- a/slither/detectors/examples/backdoor.py +++ b/slither/detectors/examples/backdoor.py @@ -26,11 +26,11 @@ class Backdoor(AbstractDetector): for f in contract.functions: if 'backdoor' in f.name: # Info to be printed - info = 'Backdoor function found in {}.{} ({})\n' - info = info.format(contract.name, f.name, f.source_mapping_str) + info = ['Backdoor function found in ', f, '\n'] + # Add the result in result json = self.generate_json_result(info) - self.add_function_to_json(f, json) + results.append(json) return results diff --git a/slither/detectors/functions/arbitrary_send.py b/slither/detectors/functions/arbitrary_send.py index d28cd1258..4a14873a9 100644 --- a/slither/detectors/functions/arbitrary_send.py +++ b/slither/detectors/functions/arbitrary_send.py @@ -109,16 +109,13 @@ Bob calls `setDestination` and `withdraw`. As a result he withdraws the contract arbitrary_send = self.detect_arbitrary_send(c) for (func, nodes) in arbitrary_send: - info = "{} ({}) sends eth to arbitrary user\n" - info = info.format(func.canonical_name, - func.source_mapping_str) - info += '\tDangerous calls:\n' + info = [func, " sends eth to arbitrary user\n"] + info += ['\tDangerous calls:\n'] for node in nodes: - info += '\t- {} ({})\n'.format(node.expression, node.source_mapping_str) + info += ['\t- ', node, '\n'] json = self.generate_json_result(info) - self.add_function_to_json(func, json) - self.add_nodes_to_json(nodes, json) + results.append(json) return results diff --git a/slither/detectors/functions/external_function.py b/slither/detectors/functions/external_function.py index 233f24f48..7b48be5ba 100644 --- a/slither/detectors/functions/external_function.py +++ b/slither/detectors/functions/external_function.py @@ -182,16 +182,13 @@ class ExternalFunction(AbstractDetector): function_definition = all_function_definitions[0] all_function_definitions = all_function_definitions[1:] - txt = f"{function_definition.full_name} should be declared external:\n" - txt += f"\t- {function_definition.canonical_name} ({function_definition.source_mapping_str})\n" + info = [f"{function_definition.full_name} should be declared external:\n"] + info += [f"\t- ", function_definition, "\n"] for other_function_definition in all_function_definitions: - txt += f"\t- {other_function_definition.canonical_name}" - txt += f" ({other_function_definition.source_mapping_str})\n" + info += [f"\t- ", other_function_definition, "\n"] + + json = self.generate_json_result(info) - json = self.generate_json_result(txt) - self.add_function_to_json(function_definition, json) - for other_function_definition in all_function_definitions: - self.add_function_to_json(other_function_definition, json) results.append(json) return results diff --git a/slither/detectors/functions/suicidal.py b/slither/detectors/functions/suicidal.py index 5f5d0f73b..2dc28cf13 100644 --- a/slither/detectors/functions/suicidal.py +++ b/slither/detectors/functions/suicidal.py @@ -73,12 +73,10 @@ Bob calls `kill` and destructs the contract.''' functions = self.detect_suicidal(c) for func in functions: - txt = "{} ({}) allows anyone to destruct the contract\n" - info = txt.format(func.canonical_name, - func.source_mapping_str) + info = [func, " allows anyone to destruct the contract\n"] json = self.generate_json_result(info) - self.add_function_to_json(func, json) + results.append(json) return results diff --git a/slither/detectors/naming_convention/naming_convention.py b/slither/detectors/naming_convention/naming_convention.py index a6499ca99..93825e419 100644 --- a/slither/detectors/naming_convention/naming_convention.py +++ b/slither/detectors/naming_convention/naming_convention.py @@ -30,6 +30,7 @@ Solidity defines a [naming convention](https://solidity.readthedocs.io/en/v0.4.2 WIKI_RECOMMENDATION = 'Follow the Solidity [naming convention](https://solidity.readthedocs.io/en/v0.4.25/style-guide.html#naming-conventions).' + STANDARD_JSON = False @staticmethod def is_cap_words(name): @@ -59,8 +60,7 @@ Solidity defines a [naming convention](https://solidity.readthedocs.io/en/v0.4.2 for contract in self.contracts: if not self.is_cap_words(contract.name): - info = "Contract '{}' ({}) is not in CapWords\n".format(contract.name, - contract.source_mapping_str) + info = ["Contract ", contract, " is not in CapWords\n"] json = self.generate_json_result(info) self.add_contract_to_json(contract, json, { @@ -71,8 +71,7 @@ Solidity defines a [naming convention](https://solidity.readthedocs.io/en/v0.4.2 for struct in contract.structures_declared: if not self.is_cap_words(struct.name): - info = "Struct '{}' ({}) is not in CapWords\n" - info = info.format(struct.canonical_name, struct.source_mapping_str) + info = ["Struct ", struct, " is not in CapWords\n"] json = self.generate_json_result(info) self.add_struct_to_json(struct, json, { @@ -83,8 +82,7 @@ Solidity defines a [naming convention](https://solidity.readthedocs.io/en/v0.4.2 for event in contract.events_declared: if not self.is_cap_words(event.name): - info = "Event '{}' ({}) is not in CapWords\n" - info = info.format(event.canonical_name, event.source_mapping_str) + info = ["Event ", event, " is not in CapWords\n"] json = self.generate_json_result(info) self.add_event_to_json(event, json, { @@ -101,8 +99,7 @@ Solidity defines a [naming convention](https://solidity.readthedocs.io/en/v0.4.2 continue if func.name.startswith("echidna_") or func.name.startswith("crytic_"): continue - info = "Function '{}' ({}) is not in mixedCase\n" - info = info.format(func.canonical_name, func.source_mapping_str) + info = ["Function ", func, " is not in mixedCase\n"] json = self.generate_json_result(info) self.add_function_to_json(func, json, { @@ -120,10 +117,7 @@ Solidity defines a [naming convention](https://solidity.readthedocs.io/en/v0.4.2 else: correct_naming = self.is_mixed_case_with_underscore(argument.name) if not correct_naming: - info = "Parameter '{}' of {} ({}) is not in mixedCase\n" - info = info.format(argument.name, - argument.canonical_name, - argument.source_mapping_str) + info = ["Parameter ", argument, " is not in mixedCase\n"] json = self.generate_json_result(info) self.add_variable_to_json(argument, json, { @@ -135,8 +129,7 @@ Solidity defines a [naming convention](https://solidity.readthedocs.io/en/v0.4.2 for var in contract.state_variables_declared: if self.should_avoid_name(var.name): if not self.is_upper_case_with_underscores(var.name): - info = "Variable '{}' ({}) used l, O, I, which should not be used\n" - info = info.format(var.canonical_name, var.source_mapping_str) + info = ["Variable ", var," used l, O, I, which should not be used\n"] json = self.generate_json_result(info) self.add_variable_to_json(var, json, { @@ -151,8 +144,7 @@ Solidity defines a [naming convention](https://solidity.readthedocs.io/en/v0.4.2 continue if not self.is_upper_case_with_underscores(var.name): - info = "Constant '{}' ({}) is not in UPPER_CASE_WITH_UNDERSCORES\n" - info = info.format(var.canonical_name, var.source_mapping_str) + info = ["Constant ", var," is not in UPPER_CASE_WITH_UNDERSCORES\n"] json = self.generate_json_result(info) self.add_variable_to_json(var, json, { @@ -167,8 +159,7 @@ Solidity defines a [naming convention](https://solidity.readthedocs.io/en/v0.4.2 else: correct_naming = self.is_mixed_case(var.name) if not correct_naming: - info = "Variable '{}' ({}) is not in mixedCase\n" - info = info.format(var.canonical_name, var.source_mapping_str) + info = ["Variable ", var, " is not in mixedCase\n"] json = self.generate_json_result(info) self.add_variable_to_json(var, json, { @@ -179,8 +170,7 @@ Solidity defines a [naming convention](https://solidity.readthedocs.io/en/v0.4.2 for enum in contract.enums_declared: if not self.is_cap_words(enum.name): - info = "Enum '{}' ({}) is not in CapWords\n" - info = info.format(enum.canonical_name, enum.source_mapping_str) + info = ["Enum ", enum, " is not in CapWords\n"] json = self.generate_json_result(info) self.add_enum_to_json(enum, json, { @@ -191,9 +181,7 @@ Solidity defines a [naming convention](https://solidity.readthedocs.io/en/v0.4.2 for modifier in contract.modifiers_declared: if not self.is_mixed_case(modifier.name): - info = "Modifier '{}' ({}) is not in mixedCase\n" - info = info.format(modifier.canonical_name, - modifier.source_mapping_str) + info = ["Modifier ", modifier, " is not in mixedCase\n"] json = self.generate_json_result(info) self.add_function_to_json(modifier, json, { diff --git a/slither/detectors/operations/block_timestamp.py b/slither/detectors/operations/block_timestamp.py index 81c115341..23ad8e178 100644 --- a/slither/detectors/operations/block_timestamp.py +++ b/slither/detectors/operations/block_timestamp.py @@ -69,16 +69,14 @@ class Timestamp(AbstractDetector): dangerous_timestamp = self.detect_dangerous_timestamp(c) for (func, nodes) in dangerous_timestamp: - info = "{} ({}) uses timestamp for comparisons\n" - info = info.format(func.canonical_name, - func.source_mapping_str) - info += '\tDangerous comparisons:\n' + info = [func, " uses timestamp for comparisons\n"] + + info += ['\tDangerous comparisons:\n'] for node in nodes: - info += '\t- {} ({})\n'.format(node.expression, node.source_mapping_str) + info += ['\t- ', node, '\n'] json = self.generate_json_result(info) - self.add_function_to_json(func, json) - self.add_nodes_to_json(nodes, json) + results.append(json) return results diff --git a/slither/detectors/operations/low_level_calls.py b/slither/detectors/operations/low_level_calls.py index 4e36448a4..c22ff8139 100644 --- a/slither/detectors/operations/low_level_calls.py +++ b/slither/detectors/operations/low_level_calls.py @@ -48,14 +48,13 @@ class LowLevelCalls(AbstractDetector): for c in self.contracts: values = self.detect_low_level_calls(c) for func, nodes in values: - info = "Low level call in {} ({}):\n" - info = info.format(func.canonical_name, func.source_mapping_str) + info = ["Low level call in ", func,":\n"] + for node in nodes: - info += "\t-{} {}\n".format(str(node.expression), node.source_mapping_str) + info += ['\t- ', node, '\n'] json = self.generate_json_result(info) - self.add_function_to_json(func, json) - self.add_nodes_to_json(nodes, json) + results.append(json) return results diff --git a/slither/detectors/operations/unused_return_values.py b/slither/detectors/operations/unused_return_values.py index 77a0e5b86..a8233a6d8 100644 --- a/slither/detectors/operations/unused_return_values.py +++ b/slither/detectors/operations/unused_return_values.py @@ -74,16 +74,10 @@ contract MyConc{ if unused_return: for node in unused_return: - info = "{} ({}) ignores return value by {} \"{}\" ({})\n" - info = info.format(f.canonical_name, - f.source_mapping_str, - self._txt_description, - node.expression, - node.source_mapping_str) + info = [f, f" ignores return value by ", node, "\n"] json = self.generate_json_result(info) - self.add_node_to_json(node, json) - self.add_function_to_json(f, json) + results.append(json) return results diff --git a/slither/detectors/operations/void_constructor.py b/slither/detectors/operations/void_constructor.py index 6be913ffa..181a5ae50 100644 --- a/slither/detectors/operations/void_constructor.py +++ b/slither/detectors/operations/void_constructor.py @@ -36,12 +36,10 @@ By reading B's constructor definition, the reader might assume that `A()` initia for constructor_call in cst.explicit_base_constructor_calls_statements: for node in constructor_call.nodes: if any(isinstance(ir, Nop) for ir in node.irs): - info = "Void constructor called in {} ({}):\n" - info = info.format(cst.canonical_name, cst.source_mapping_str) - info += "\t-{} {}\n".format(str(node.expression), node.source_mapping_str) + info = ["Void constructor called in ", cst, ":\n"] + info += ["\t- ", node, "\n"] json = self.generate_json_result(info) - self.add_function_to_json(cst, json) - self.add_nodes_to_json([node], json) + results.append(json) return results diff --git a/slither/detectors/reentrancy/reentrancy_benign.py b/slither/detectors/reentrancy/reentrancy_benign.py index 2d16d757f..79dfec78f 100644 --- a/slither/detectors/reentrancy/reentrancy_benign.py +++ b/slither/detectors/reentrancy/reentrancy_benign.py @@ -36,6 +36,8 @@ Only report reentrancy that acts as a double call (see `reentrancy-eth`, `reentr WIKI_RECOMMENDATION = 'Apply the [check-effects-interactions pattern](http://solidity.readthedocs.io/en/v0.4.21/security-considerations.html#re-entrancy).' + STANDARD_JSON = False + def find_reentrancies(self): result = {} for contract in self.contracts: @@ -78,18 +80,19 @@ Only report reentrancy that acts as a double call (see `reentrancy-eth`, `reentr for (func, calls, send_eth), varsWritten in result_sorted: calls = sorted(list(set(calls)), key=lambda x: x.node_id) send_eth = sorted(list(set(send_eth)), key=lambda x: x.node_id) - info = 'Reentrancy in {} ({}):\n' - info = info.format(func.canonical_name, func.source_mapping_str) - info += '\tExternal calls:\n' + info = ['Reentrancy in ', func, ':\n'] + + info += ['\tExternal calls:\n'] for call_info in calls: - info += '\t- {} ({})\n'.format(call_info.expression, call_info.source_mapping_str) + info += ['\t- ' , call_info, '\n'] if calls != send_eth and send_eth: - info += '\tExternal calls sending eth:\n' + info += ['\tExternal calls sending eth:\n'] for call_info in send_eth: - info += '\t- {} ({})\n'.format(call_info.expression, call_info.source_mapping_str) - info += '\tState variables written after the call(s):\n' + info += ['\t- ', call_info, '\n'] + info += ['\tState variables written after the call(s):\n'] for (v, node) in sorted(varsWritten, key=lambda x: (x[0].name, x[1].node_id)): - info += '\t- {} ({})\n'.format(v, node.source_mapping_str) + info += ['\t- ', v, ' in ', node, '\n'] + # Create our JSON result json = self.generate_json_result(info) diff --git a/slither/detectors/reentrancy/reentrancy_eth.py b/slither/detectors/reentrancy/reentrancy_eth.py index 4439887aa..b0d501ec1 100644 --- a/slither/detectors/reentrancy/reentrancy_eth.py +++ b/slither/detectors/reentrancy/reentrancy_eth.py @@ -37,6 +37,7 @@ Bob uses the re-entrancy bug to call `withdrawBalance` two times, and withdraw m WIKI_RECOMMENDATION = 'Apply the [check-effects-interactions pattern](http://solidity.readthedocs.io/en/v0.4.21/security-considerations.html#re-entrancy).' + STANDARD_JSON = False def find_reentrancies(self): result = {} @@ -81,18 +82,17 @@ Bob uses the re-entrancy bug to call `withdrawBalance` two times, and withdraw m calls = sorted(list(set(calls)), key=lambda x: x.node_id) send_eth = sorted(list(set(send_eth)), key=lambda x: x.node_id) - info = 'Reentrancy in {} ({}):\n' - info = info.format(func.canonical_name, func.source_mapping_str) - info += '\tExternal calls:\n' + info = ['Reentrancy in ', func, ':\n'] + info += ['\tExternal calls:\n'] for call_info in calls: - info += '\t- {} ({})\n'.format(call_info.expression, call_info.source_mapping_str) - if calls != send_eth: - info += '\tExternal calls sending eth:\n' + info += ['\t- ' , call_info, '\n'] + if calls != send_eth and send_eth: + info += ['\tExternal calls sending eth:\n'] for call_info in send_eth: - info += '\t- {} ({})\n'.format(call_info.expression, call_info.source_mapping_str) - info += '\tState variables written after the call(s):\n' + info += ['\t- ', call_info, '\n'] + info += ['\tState variables written after the call(s):\n'] for (v, node) in sorted(varsWritten, key=lambda x: (x[0].name, x[1].node_id)): - info += '\t- {} ({})\n'.format(v, node.source_mapping_str) + info += ['\t- ', v, ' in ', node, '\n'] # Create our JSON result json = self.generate_json_result(info) diff --git a/slither/detectors/reentrancy/reentrancy_read_before_write.py b/slither/detectors/reentrancy/reentrancy_read_before_write.py index 0432459cc..6389847fc 100644 --- a/slither/detectors/reentrancy/reentrancy_read_before_write.py +++ b/slither/detectors/reentrancy/reentrancy_read_before_write.py @@ -36,6 +36,8 @@ Do not report reentrancies that involve ethers (see `reentrancy-eth`)''' ''' WIKI_RECOMMENDATION = 'Apply the [check-effects-interactions pattern](http://solidity.readthedocs.io/en/v0.4.21/security-considerations.html#re-entrancy).' + STANDARD_JSON = False + def find_reentrancies(self): result = {} for contract in self.contracts: @@ -75,14 +77,15 @@ Do not report reentrancies that involve ethers (see `reentrancy-eth`)''' result_sorted = sorted(list(reentrancies.items()), key=lambda x:x[0][0].name) for (func, calls), varsWritten in result_sorted: calls = sorted(list(set(calls)), key=lambda x: x.node_id) - info = 'Reentrancy in {} ({}):\n' - info = info.format(func.canonical_name, func.source_mapping_str) - info += '\tExternal calls:\n' + + info = ['Reentrancy in ', func, ':\n'] + + info += ['\tExternal calls:\n'] for call_info in calls: - info += '\t- {} ({})\n'.format(call_info.expression, call_info.source_mapping_str) + info += ['\t- ', call_info, '\n'] info += '\tState variables written after the call(s):\n' for (v, node) in sorted(varsWritten, key=lambda x: (x[0].name, x[1].node_id)): - info += '\t- {} ({})\n'.format(v, node.source_mapping_str) + info += ['\t- ', v, ' in ', node, '\n'] # Create our JSON result json = self.generate_json_result(info) diff --git a/slither/detectors/shadowing/abstract.py b/slither/detectors/shadowing/abstract.py index 15bb7e2c1..f2e7c7119 100644 --- a/slither/detectors/shadowing/abstract.py +++ b/slither/detectors/shadowing/abstract.py @@ -65,14 +65,12 @@ contract DerivedContract is BaseContract{ for all_variables in shadowing: shadow = all_variables[0] variables = all_variables[1:] - info = '{} ({}) shadows:\n'.format(shadow.canonical_name, - shadow.source_mapping_str) + info = [shadow, ' shadows:\n'] for var in variables: - info += "\t- {} ({})\n".format(var.canonical_name, - var.source_mapping_str) + info += ["\t- ", var, "\n"] json = self.generate_json_result(info) - self.add_variables_to_json(all_variables, json) + results.append(json) return results diff --git a/slither/detectors/shadowing/builtin_symbols.py b/slither/detectors/shadowing/builtin_symbols.py index 2cd4cff09..c0bf4e8b0 100644 --- a/slither/detectors/shadowing/builtin_symbols.py +++ b/slither/detectors/shadowing/builtin_symbols.py @@ -77,7 +77,7 @@ contract Bug { results = [] for local in function_or_modifier.variables: if self.is_builtin_symbol(local.name): - results.append((self.SHADOWING_LOCAL_VARIABLE, local, function_or_modifier)) + results.append((self.SHADOWING_LOCAL_VARIABLE, local)) return results def detect_builtin_shadowing_definitions(self, contract): @@ -92,18 +92,18 @@ contract Bug { # Loop through all functions, modifiers, variables (state and local) to detect any built-in symbol keywords. for function in contract.functions_declared: if self.is_builtin_symbol(function.name): - result.append((self.SHADOWING_FUNCTION, function, None)) + result.append((self.SHADOWING_FUNCTION, function)) result += self.detect_builtin_shadowing_locals(function) for modifier in contract.modifiers_declared: if self.is_builtin_symbol(modifier.name): - result.append((self.SHADOWING_MODIFIER, modifier, None)) + result.append((self.SHADOWING_MODIFIER, modifier)) result += self.detect_builtin_shadowing_locals(modifier) for variable in contract.state_variables_declared: if self.is_builtin_symbol(variable.name): - result.append((self.SHADOWING_STATE_VARIABLE, variable, None)) + result.append((self.SHADOWING_STATE_VARIABLE, variable)) for event in contract.events_declared: if self.is_builtin_symbol(event.name): - result.append((self.SHADOWING_EVENT, event, None)) + result.append((self.SHADOWING_EVENT, event)) return result @@ -124,27 +124,10 @@ contract Bug { # Obtain components shadow_type = shadow[0] shadow_object = shadow[1] - local_variable_parent = shadow[2] - # Build the path for our info string - local_variable_path = contract.name + "." - if local_variable_parent is not None: - local_variable_path += local_variable_parent.name + "." - local_variable_path += shadow_object.name + info = [shadow_object, f' ({shadow_type}) shadows built-in symbol"\n'] - info = '{} ({} @ {}) shadows built-in symbol \"{}"\n'.format(local_variable_path, - shadow_type, - shadow_object.source_mapping_str, - shadow_object.name) - - # Generate relevant JSON data for this shadowing definition. json = self.generate_json_result(info) - if shadow_type in [self.SHADOWING_FUNCTION, self.SHADOWING_MODIFIER]: - self.add_function_to_json(shadow_object, json) - elif shadow_type == self.SHADOWING_EVENT: - self.add_event_to_json(shadow_object, json) - elif shadow_type in [self.SHADOWING_STATE_VARIABLE, self.SHADOWING_LOCAL_VARIABLE]: - self.add_variable_to_json(shadow_object, json) results.append(json) return results diff --git a/slither/detectors/shadowing/local.py b/slither/detectors/shadowing/local.py index 66f769882..0da45cf99 100644 --- a/slither/detectors/shadowing/local.py +++ b/slither/detectors/shadowing/local.py @@ -68,23 +68,23 @@ contract Bug { # Check functions for scope_function in scope_contract.functions_declared: if variable.name == scope_function.name: - overshadowed.append((self.OVERSHADOWED_FUNCTION, scope_contract.name, scope_function)) + overshadowed.append((self.OVERSHADOWED_FUNCTION, scope_function)) # Check modifiers for scope_modifier in scope_contract.modifiers_declared: if variable.name == scope_modifier.name: - overshadowed.append((self.OVERSHADOWED_MODIFIER, scope_contract.name, scope_modifier)) + overshadowed.append((self.OVERSHADOWED_MODIFIER, scope_modifier)) # Check events for scope_event in scope_contract.events_declared: if variable.name == scope_event.name: - overshadowed.append((self.OVERSHADOWED_EVENT, scope_contract.name, scope_event)) + overshadowed.append((self.OVERSHADOWED_EVENT, scope_event)) # Check state variables for scope_state_variable in scope_contract.state_variables_declared: if variable.name == scope_state_variable.name: - overshadowed.append((self.OVERSHADOWED_STATE_VARIABLE, scope_contract.name, scope_state_variable)) + overshadowed.append((self.OVERSHADOWED_STATE_VARIABLE, scope_state_variable)) # If we have found any overshadowed objects, we'll want to add it to our result list. if overshadowed: - result.append((contract.name, function.name, variable, overshadowed)) + result.append((variable, overshadowed)) return result @@ -102,29 +102,15 @@ contract Bug { shadows = self.detect_shadowing_definitions(contract) if shadows: for shadow in shadows: - local_parent_name = shadow[1] - local_variable = shadow[2] - overshadowed = shadow[3] - info = '{}.{}.{} (local variable @ {}) shadows:\n'.format(contract.name, - local_parent_name, - local_variable.name, - local_variable.source_mapping_str) + local_variable = shadow[0] + overshadowed = shadow[1] + info = [local_variable, ' shadows:\n'] for overshadowed_entry in overshadowed: - info += "\t- {}.{} ({} @ {})\n".format(overshadowed_entry[1], - overshadowed_entry[2], - overshadowed_entry[0], - overshadowed_entry[2].source_mapping_str) + info += ["\t- ", overshadowed_entry[1], f" ({overshadowed_entry[0]})\n"] # Generate relevant JSON data for this shadowing definition. json = self.generate_json_result(info) - self.add_variable_to_json(local_variable, json) - for overshadowed_entry in overshadowed: - if overshadowed_entry[0] in [self.OVERSHADOWED_FUNCTION, self.OVERSHADOWED_MODIFIER]: - self.add_function_to_json(overshadowed_entry[2], json) - elif overshadowed_entry[0] == self.OVERSHADOWED_EVENT: - self.add_event_to_json(overshadowed_entry[2], json) - elif overshadowed_entry[0] == self.OVERSHADOWED_STATE_VARIABLE: - self.add_variable_to_json(overshadowed_entry[2], json) + results.append(json) return results diff --git a/slither/detectors/shadowing/state.py b/slither/detectors/shadowing/state.py index 41da711f3..b5df61151 100644 --- a/slither/detectors/shadowing/state.py +++ b/slither/detectors/shadowing/state.py @@ -76,14 +76,12 @@ contract DerivedContract is BaseContract{ for all_variables in shadowing: shadow = all_variables[0] variables = all_variables[1:] - info = '{} ({}) shadows:\n'.format(shadow.canonical_name, - shadow.source_mapping_str) + info = [shadow, ' shadows:\n'] for var in variables: - info += "\t- {} ({})\n".format(var.canonical_name, - var.source_mapping_str) + info += ["\t- ", var, "\n"] json = self.generate_json_result(info) - self.add_variables_to_json(all_variables, json) + results.append(json) diff --git a/slither/detectors/source/rtlo.py b/slither/detectors/source/rtlo.py index 7c4b78305..135b5aa6a 100644 --- a/slither/detectors/source/rtlo.py +++ b/slither/detectors/source/rtlo.py @@ -46,6 +46,7 @@ contract Token WIKI_RECOMMENDATION = 'Special control characters must not be allowed.' RTLO_CHARACTER_ENCODED = "\u202e".encode('utf-8') + STANDARD_JSON = False def _detect(self): results = [] diff --git a/slither/detectors/statements/assembly.py b/slither/detectors/statements/assembly.py index 936794366..af65f2331 100644 --- a/slither/detectors/statements/assembly.py +++ b/slither/detectors/statements/assembly.py @@ -51,15 +51,12 @@ class Assembly(AbstractDetector): for c in self.contracts: values = self.detect_assembly(c) for func, nodes in values: - info = "{} uses assembly ({})\n" - info = info.format(func.canonical_name, func.source_mapping_str) + info = [func, " uses assembly\n"] for node in nodes: - info += "\t- {}\n".format(node.source_mapping_str) + info += ["\t- ", node, "\n"] json = self.generate_json_result(info) - self.add_function_to_json(func, json) - self.add_nodes_to_json(nodes, json) results.append(json) return results diff --git a/slither/detectors/statements/calls_in_loop.py b/slither/detectors/statements/calls_in_loop.py index 092003c8f..b2dfd5c11 100644 --- a/slither/detectors/statements/calls_in_loop.py +++ b/slither/detectors/statements/calls_in_loop.py @@ -87,11 +87,8 @@ If one of the destinations has a fallback function which reverts, `bad` will alw for node in values: func = node.function - info = "{} has external calls inside a loop: \"{}\" ({})\n" - info = info.format(func.canonical_name, node.expression, node.source_mapping_str) - + info = [func, " has external calls inside a loop: ", node, "\n"] json = self.generate_json_result(info) - self.add_node_to_json(node, json) results.append(json) return results diff --git a/slither/detectors/statements/controlled_delegatecall.py b/slither/detectors/statements/controlled_delegatecall.py index 455be0594..0dcff87bc 100644 --- a/slither/detectors/statements/controlled_delegatecall.py +++ b/slither/detectors/statements/controlled_delegatecall.py @@ -47,14 +47,11 @@ Bob calls `delegate` and delegates the execution to its malicious contract. As a continue nodes = self.controlled_delegatecall(f) if nodes: - func_info = '{}.{} ({}) uses delegatecall to a input-controlled function id\n' - func_info = func_info.format(contract.name, f.name, f.source_mapping_str) - for node in nodes: - node_info = func_info + '\t- {} ({})\n'.format(node.expression, node.source_mapping_str) + func_info = [f, ' uses delegatecall to a input-controlled function id\n'] + for node in nodes: + node_info = func_info + ['\t- ', node,'\n'] json = self.generate_json_result(node_info) - self.add_node_to_json(node, json) - self.add_function_to_json(f, json) results.append(json) return results diff --git a/slither/detectors/statements/deprecated_calls.py b/slither/detectors/statements/deprecated_calls.py index c18843125..de8b8e860 100644 --- a/slither/detectors/statements/deprecated_calls.py +++ b/slither/detectors/statements/deprecated_calls.py @@ -152,20 +152,12 @@ contract ContractWithDeprecatedReferences { for deprecated_reference in deprecated_references: source_object = deprecated_reference[0] deprecated_entries = deprecated_reference[1] - info = 'Deprecated standard detected @ {}:\n'.format(source_object.source_mapping_str) + info = ['Deprecated standard detected ', source_object, ':\n'] for (dep_id, original_desc, recommended_disc) in deprecated_entries: - info += "\t- Usage of \"{}\" should be replaced with \"{}\"\n".format(original_desc, - recommended_disc) + info += [f"\t- Usage of \"{original_desc}\" should be replaced with \"{recommended_disc}\"\n"] - - # Generate relevant JSON data for this deprecated standard. json = self.generate_json_result(info) - if isinstance(source_object, StateVariableSolc) or isinstance(source_object, StateVariable): - self.add_variable_to_json(source_object, json) - else: - self.add_nodes_to_json([source_object], json) - results.append(json) return results diff --git a/slither/detectors/statements/incorrect_strict_equality.py b/slither/detectors/statements/incorrect_strict_equality.py index 0ef6a5dea..01faf4d62 100644 --- a/slither/detectors/statements/incorrect_strict_equality.py +++ b/slither/detectors/statements/incorrect_strict_equality.py @@ -111,19 +111,16 @@ contract Crowdsale{ ret = sorted(list(ret.items()), key=lambda x:x[0].name) for f, nodes in ret: - func_info = "{} ({}) uses a dangerous strict equality:\n".format(f.canonical_name, - f.source_mapping_str) + func_info = [f, " uses a dangerous strict equality:\n"] # sort the nodes to get deterministic results nodes.sort(key=lambda x: x.node_id) # Output each node with the function info header as a separate result. for node in nodes: - node_info = func_info + f"\t- {str(node.expression)}\n" + node_info = func_info + [f"\t- ", node, "\n"] json = self.generate_json_result(node_info) - self.add_node_to_json(node, json) - self.add_function_to_json(f, json) results.append(json) return results diff --git a/slither/detectors/statements/too_many_digits.py b/slither/detectors/statements/too_many_digits.py index df9e21921..0e6591546 100644 --- a/slither/detectors/statements/too_many_digits.py +++ b/slither/detectors/statements/too_many_digits.py @@ -64,15 +64,12 @@ Use: # iterate over all the nodes ret = self._detect_too_many_digits(f) if ret: - func_info = '{}.{} ({}) uses literals with too many digits:'.format(f.contract.name, - f.name, - f.source_mapping_str) + func_info = [f, ' uses literals with too many digits:'] for node in ret: - node_info = func_info + '\n\t- {}\n'.format(node.expression) + node_info = func_info + ['\n\t- ', node,'\n'] # Add the result in result json = self.generate_json_result(node_info) - self.add_node_to_json(node, json) results.append(json) return results diff --git a/slither/detectors/statements/tx_origin.py b/slither/detectors/statements/tx_origin.py index 3b4e662a7..8f2b9968b 100644 --- a/slither/detectors/statements/tx_origin.py +++ b/slither/detectors/statements/tx_origin.py @@ -68,12 +68,9 @@ Bob is the owner of `TxOrigin`. Bob calls Eve's contract. Eve's contract calls ` for func, nodes in values: for node in nodes: - info = "{} uses tx.origin for authorization: \"{}\" ({})\n".format(func.canonical_name, - node.expression, - node.source_mapping_str) - + info = [func, " uses tx.origin for authorization: ", node, "\n"] json = self.generate_json_result(info) - self.add_node_to_json(node, json) + results.append(json) return results diff --git a/slither/detectors/variables/possible_const_state_variables.py b/slither/detectors/variables/possible_const_state_variables.py index e6c676c16..eaed2dac8 100644 --- a/slither/detectors/variables/possible_const_state_variables.py +++ b/slither/detectors/variables/possible_const_state_variables.py @@ -88,11 +88,8 @@ class ConstCandidateStateVars(AbstractDetector): # Create a result for each finding for v in constable_variables: - info = "{} should be constant ({})\n".format(v.canonical_name, - v.source_mapping_str) + info = [v, " should be constant\n"] json = self.generate_json_result(info) - self.add_variable_to_json(v, json) - results.append(json) return results diff --git a/slither/detectors/variables/uninitialized_local_variables.py b/slither/detectors/variables/uninitialized_local_variables.py index c767e7b2c..cc0ff0968 100644 --- a/slither/detectors/variables/uninitialized_local_variables.py +++ b/slither/detectors/variables/uninitialized_local_variables.py @@ -97,17 +97,9 @@ Bob calls `transfer`. As a result, the ethers are sent to the address 0x0 and ar self._detect_uninitialized(function, function.entry_point, []) all_results = list(set(self.results)) for(function, uninitialized_local_variable) in all_results: - var_name = uninitialized_local_variable.name - - info = "{} in {} ({}) is a local variable never initialiazed\n" - info = info.format(var_name, - function.canonical_name, - uninitialized_local_variable.source_mapping_str) - + info = [uninitialized_local_variable, " is a local variable never initialiazed\n"] json = self.generate_json_result(info) - self.add_variable_to_json(uninitialized_local_variable, json) - self.add_function_to_json(function, json) results.append(json) return results diff --git a/slither/detectors/variables/uninitialized_state_variables.py b/slither/detectors/variables/uninitialized_state_variables.py index 86a9e09d3..8eaa784e6 100644 --- a/slither/detectors/variables/uninitialized_state_variables.py +++ b/slither/detectors/variables/uninitialized_state_variables.py @@ -87,18 +87,13 @@ Initialize all the variables. If a variable is meant to be initialized to zero, for c in self.slither.contracts_derived: ret = self.detect_uninitialized(c) for variable, functions in ret: - info = "{} ({}) is never initialized. It is used in:\n" - info = info.format(variable.canonical_name, - variable.source_mapping_str) - for f in functions: - info += "\t- {} ({})\n".format(f.name, f.source_mapping_str) - source = [variable.source_mapping] - source += [f.source_mapping for f in functions] + info = [variable, " is never initialized. It is used in:\n"] + + for f in functions: + info += ["\t- ", f, "\n"] json = self.generate_json_result(info) - self.add_variable_to_json(variable, json) - self.add_functions_to_json(functions, json) results.append(json) return results diff --git a/slither/detectors/variables/uninitialized_storage_variables.py b/slither/detectors/variables/uninitialized_storage_variables.py index 78f7b8343..f77f95d2a 100644 --- a/slither/detectors/variables/uninitialized_storage_variables.py +++ b/slither/detectors/variables/uninitialized_storage_variables.py @@ -101,14 +101,8 @@ Bob calls `func`. As a result, `owner` is override to 0. self._detect_uninitialized(function, function.entry_point, []) for(function, uninitialized_storage_variable) in self.results: - var_name = uninitialized_storage_variable.name - - info = "{} in {} ({}) is a storage variable never initialiazed\n" - info = info.format(var_name, function.canonical_name, uninitialized_storage_variable.source_mapping_str) - + info = [uninitialized_storage_variable, " is a storage variable never initialiazed\n"] json = self.generate_json_result(info) - self.add_variable_to_json(uninitialized_storage_variable, json) - self.add_function_to_json(function, json) results.append(json) return results diff --git a/slither/detectors/variables/unused_state_variables.py b/slither/detectors/variables/unused_state_variables.py index 35fa66999..def3d2804 100644 --- a/slither/detectors/variables/unused_state_variables.py +++ b/slither/detectors/variables/unused_state_variables.py @@ -60,13 +60,8 @@ class UnusedStateVars(AbstractDetector): unusedVars = self.detect_unused(c) if unusedVars: for var in unusedVars: - info = "{} ({}) is never used in {}\n".format(var.canonical_name, - var.source_mapping_str, - c.name) - + info = [var, " is never used in ", c, "\n"] json = self.generate_json_result(info) - self.add_variable_to_json(var, json) - self.add_contract_to_json(c, json) results.append(json) return results diff --git a/slither/slither.py b/slither/slither.py index af07cfd93..1dbf9e7ce 100644 --- a/slither/slither.py +++ b/slither/slither.py @@ -68,6 +68,8 @@ class Slither(SlitherSolc): if kwargs.get('generate_patches', False): self.generate_patches = True + self._markdown_root = kwargs.get('markdown_root', "") + self._detectors = [] self._printers = [] diff --git a/slither/utils/json_utils.py b/slither/utils/json_utils.py index 8aecc8230..3ae2b8862 100644 --- a/slither/utils/json_utils.py +++ b/slither/utils/json_utils.py @@ -3,7 +3,11 @@ import json import logging from collections import OrderedDict +from slither.core.cfg.node import Node +from slither.core.declarations import Contract, Function, Enum, Event, Structure, Pragma from slither.core.source_mapping.source_mapping import SourceMapping +from slither.core.variables.variable import Variable +from slither.exceptions import SlitherError from slither.utils.colors import yellow logger = logging.getLogger("Slither") @@ -54,12 +58,79 @@ def output_json(filename, error, results): ################################################################################### ################################################################################### -def generate_json_result(info, additional_fields=None): +def _convert_to_description(d): + if isinstance(d, str): + return d + + if not isinstance(d, SourceMapping): + raise SlitherError(f'{d} does not inherit from SourceMapping, conversion impossible') + + if isinstance(d, Node): + if d.expression: + return f'{d.expression} ({d.source_mapping_str})' + else: + return f'{str(d)} ({d.source_mapping_str})' + + if hasattr(d, 'canonical_name'): + return f'{d.canonical_name} ({d.source_mapping_str})' + + if hasattr(d, 'name'): + return f'{d.name} ({d.source_mapping_str})' + + raise SlitherError(f'{type(d)} cannot be converted (no name, or canonical_name') + +def _convert_to_markdown(d, markdown_root): + if isinstance(d, str): + return d + + if not isinstance(d, SourceMapping): + raise SlitherError(f'{d} does not inherit from SourceMapping, conversion impossible') + + if isinstance(d, Node): + if d.expression: + return f'[{d.expression}]({d.source_mapping_to_markdown(markdown_root)})' + else: + return f'[{str(d)}]({d.source_mapping_to_markdown(markdown_root)})' + + if hasattr(d, 'canonical_name'): + return f'[{d.canonical_name}]({d.source_mapping_to_markdown(markdown_root)})' + + if hasattr(d, 'name'): + return f'[{d.name}]({d.source_mapping_to_markdown(markdown_root)})' + + raise SlitherError(f'{type(d)} cannot be converted (no name, or canonical_name') + +def generate_json_result(info, additional_fields=None, markdown_root='', standard_format=False): if additional_fields is None: additional_fields = {} d = OrderedDict() d['elements'] = [] - d['description'] = info + d['description'] = ''.join(_convert_to_description(d) for d in info) + d['markdown'] = ''.join(_convert_to_markdown(d, markdown_root) for d in info) + + if standard_format: + to_add = [i for i in info if not isinstance(i, str)] + + for add in to_add: + if isinstance(add, Variable): + add_variable_to_json(add, d) + elif isinstance(add, Contract): + add_contract_to_json(add, d) + elif isinstance(add, Function): + add_function_to_json(add, d) + elif isinstance(add, Enum): + add_enum_to_json(add, d) + elif isinstance(add, Event): + add_event_to_json(add, d) + elif isinstance(add, Structure): + add_struct_to_json(add, d) + elif isinstance(add, Pragma): + add_pragma_to_json(add, d) + elif isinstance(add, Node): + add_node_to_json(add, d) + else: + raise SlitherError(f'Impossible to add {type(add)} to the json') + if additional_fields: d['additional_fields'] = additional_fields diff --git a/tests/expected_json/arbitrary_send-0.5.1.arbitrary-send.json b/tests/expected_json/arbitrary_send-0.5.1.arbitrary-send.json index 6e544d0c4..09c8fb7b9 100644 --- a/tests/expected_json/arbitrary_send-0.5.1.arbitrary-send.json +++ b/tests/expected_json/arbitrary_send-0.5.1.arbitrary-send.json @@ -4,10 +4,6 @@ "results": { "detectors": [ { - "check": "arbitrary-send", - "impact": "High", - "confidence": "Medium", - "description": "Test.direct() (tests/arbitrary_send-0.5.1.sol#11-13) sends eth to arbitrary user\n\tDangerous calls:\n\t- msg.sender.send(address(this).balance) (tests/arbitrary_send-0.5.1.sol#12)\n", "elements": [ { "type": "function", @@ -191,13 +187,14 @@ } } } - ] - }, - { + ], + "description": "Test.direct() (tests/arbitrary_send-0.5.1.sol#11-13) sends eth to arbitrary user\n\tDangerous calls:\n\t- msg.sender.send(address(this).balance) (tests/arbitrary_send-0.5.1.sol#12)\n", + "markdown": "[Test.direct()](tests/arbitrary_send-0.5.1.sol#L11-L13) sends eth to arbitrary user\n\tDangerous calls:\n\t- [msg.sender.send(address(this).balance)](tests/arbitrary_send-0.5.1.sol#L12)\n", "check": "arbitrary-send", "impact": "High", - "confidence": "Medium", - "description": "Test.indirect() (tests/arbitrary_send-0.5.1.sol#19-21) sends eth to arbitrary user\n\tDangerous calls:\n\t- destination.send(address(this).balance) (tests/arbitrary_send-0.5.1.sol#20)\n", + "confidence": "Medium" + }, + { "elements": [ { "type": "function", @@ -381,7 +378,12 @@ } } } - ] + ], + "description": "Test.indirect() (tests/arbitrary_send-0.5.1.sol#19-21) sends eth to arbitrary user\n\tDangerous calls:\n\t- destination.send(address(this).balance) (tests/arbitrary_send-0.5.1.sol#20)\n", + "markdown": "[Test.indirect()](tests/arbitrary_send-0.5.1.sol#L19-L21) sends eth to arbitrary user\n\tDangerous calls:\n\t- [destination.send(address(this).balance)](tests/arbitrary_send-0.5.1.sol#L20)\n", + "check": "arbitrary-send", + "impact": "High", + "confidence": "Medium" } ] } diff --git a/tests/expected_json/arbitrary_send-0.5.1.arbitrary-send.txt b/tests/expected_json/arbitrary_send-0.5.1.arbitrary-send.txt index cc2b1953f..f439b3e58 100644 --- a/tests/expected_json/arbitrary_send-0.5.1.arbitrary-send.txt +++ b/tests/expected_json/arbitrary_send-0.5.1.arbitrary-send.txt @@ -1,4 +1,4 @@ -INFO:Detectors: + Test.direct() (tests/arbitrary_send-0.5.1.sol#11-13) sends eth to arbitrary user Dangerous calls: - msg.sender.send(address(this).balance) (tests/arbitrary_send-0.5.1.sol#12) @@ -6,4 +6,4 @@ Test.indirect() (tests/arbitrary_send-0.5.1.sol#19-21) sends eth to arbitrary us Dangerous calls: - destination.send(address(this).balance) (tests/arbitrary_send-0.5.1.sol#20) Reference: https://github.com/crytic/slither/wiki/Detector-Documentation#functions-that-send-ether-to-arbitrary-destinations -INFO:Slither:tests/arbitrary_send-0.5.1.sol analyzed (1 contracts), 2 result(s) found +tests/arbitrary_send-0.5.1.sol analyzed (1 contracts with 1 detectors), 2 result(s) found diff --git a/tests/expected_json/arbitrary_send.arbitrary-send.json b/tests/expected_json/arbitrary_send.arbitrary-send.json index 993747b20..1d6122843 100644 --- a/tests/expected_json/arbitrary_send.arbitrary-send.json +++ b/tests/expected_json/arbitrary_send.arbitrary-send.json @@ -4,10 +4,6 @@ "results": { "detectors": [ { - "check": "arbitrary-send", - "impact": "High", - "confidence": "Medium", - "description": "Test.direct() (tests/arbitrary_send.sol#11-13) sends eth to arbitrary user\n\tDangerous calls:\n\t- msg.sender.send(address(this).balance) (tests/arbitrary_send.sol#12)\n", "elements": [ { "type": "function", @@ -191,13 +187,14 @@ } } } - ] - }, - { + ], + "description": "Test.direct() (tests/arbitrary_send.sol#11-13) sends eth to arbitrary user\n\tDangerous calls:\n\t- msg.sender.send(address(this).balance) (tests/arbitrary_send.sol#12)\n", + "markdown": "[Test.direct()](tests/arbitrary_send.sol#L11-L13) sends eth to arbitrary user\n\tDangerous calls:\n\t- [msg.sender.send(address(this).balance)](tests/arbitrary_send.sol#L12)\n", "check": "arbitrary-send", "impact": "High", - "confidence": "Medium", - "description": "Test.indirect() (tests/arbitrary_send.sol#19-21) sends eth to arbitrary user\n\tDangerous calls:\n\t- destination.send(address(this).balance) (tests/arbitrary_send.sol#20)\n", + "confidence": "Medium" + }, + { "elements": [ { "type": "function", @@ -381,7 +378,12 @@ } } } - ] + ], + "description": "Test.indirect() (tests/arbitrary_send.sol#19-21) sends eth to arbitrary user\n\tDangerous calls:\n\t- destination.send(address(this).balance) (tests/arbitrary_send.sol#20)\n", + "markdown": "[Test.indirect()](tests/arbitrary_send.sol#L19-L21) sends eth to arbitrary user\n\tDangerous calls:\n\t- [destination.send(address(this).balance)](tests/arbitrary_send.sol#L20)\n", + "check": "arbitrary-send", + "impact": "High", + "confidence": "Medium" } ] } diff --git a/tests/expected_json/arbitrary_send.arbitrary-send.txt b/tests/expected_json/arbitrary_send.arbitrary-send.txt index ee8440aa4..4b8a2e920 100644 --- a/tests/expected_json/arbitrary_send.arbitrary-send.txt +++ b/tests/expected_json/arbitrary_send.arbitrary-send.txt @@ -1,4 +1,4 @@ -INFO:Detectors: + Test.direct() (tests/arbitrary_send.sol#11-13) sends eth to arbitrary user Dangerous calls: - msg.sender.send(address(this).balance) (tests/arbitrary_send.sol#12) @@ -6,4 +6,4 @@ Test.indirect() (tests/arbitrary_send.sol#19-21) sends eth to arbitrary user Dangerous calls: - destination.send(address(this).balance) (tests/arbitrary_send.sol#20) Reference: https://github.com/crytic/slither/wiki/Detector-Documentation#functions-that-send-ether-to-arbitrary-destinations -INFO:Slither:tests/arbitrary_send.sol analyzed (1 contracts), 2 result(s) found +tests/arbitrary_send.sol analyzed (1 contracts with 1 detectors), 2 result(s) found diff --git a/tests/expected_json/backdoor.backdoor.json b/tests/expected_json/backdoor.backdoor.json index 243fabcc7..beae48a85 100644 --- a/tests/expected_json/backdoor.backdoor.json +++ b/tests/expected_json/backdoor.backdoor.json @@ -4,10 +4,6 @@ "results": { "detectors": [ { - "check": "backdoor", - "impact": "High", - "confidence": "High", - "description": "Backdoor function found in C.i_am_a_backdoor (tests/backdoor.sol#4-6)\n", "elements": [ { "type": "function", @@ -56,7 +52,12 @@ "signature": "i_am_a_backdoor()" } } - ] + ], + "description": "Backdoor function found in C.i_am_a_backdoor() (tests/backdoor.sol#4-6)\n", + "markdown": "Backdoor function found in [C.i_am_a_backdoor()](tests/backdoor.sol#L4-L6)\n", + "check": "backdoor", + "impact": "High", + "confidence": "High" } ] } diff --git a/tests/expected_json/backdoor.backdoor.txt b/tests/expected_json/backdoor.backdoor.txt index 76d21139d..68d34c305 100644 --- a/tests/expected_json/backdoor.backdoor.txt +++ b/tests/expected_json/backdoor.backdoor.txt @@ -1,5 +1,5 @@ -INFO:Detectors: -Backdoor function found in C.i_am_a_backdoor (tests/backdoor.sol#4-6) + +Backdoor function found in C.i_am_a_backdoor() (tests/backdoor.sol#4-6) Reference: https://github.com/trailofbits/slither/wiki/Adding-a-new-detector +tests/backdoor.sol analyzed (1 contracts with 1 detectors), 1 result(s) found INFO:Slither:/home/travis/build/crytic/slither/scripts/../tests/expected_json/backdoor.backdoor.json exists already, the overwrite is prevented -INFO:Slither:tests/backdoor.sol analyzed (1 contracts), 1 result(s) found diff --git a/tests/expected_json/backdoor.suicidal.json b/tests/expected_json/backdoor.suicidal.json index 73ff578a5..ae632e1dc 100644 --- a/tests/expected_json/backdoor.suicidal.json +++ b/tests/expected_json/backdoor.suicidal.json @@ -4,10 +4,6 @@ "results": { "detectors": [ { - "check": "suicidal", - "impact": "High", - "confidence": "High", - "description": "C.i_am_a_backdoor() (tests/backdoor.sol#4-6) allows anyone to destruct the contract\n", "elements": [ { "type": "function", @@ -56,7 +52,12 @@ "signature": "i_am_a_backdoor()" } } - ] + ], + "description": "C.i_am_a_backdoor() (tests/backdoor.sol#4-6) allows anyone to destruct the contract\n", + "markdown": "[C.i_am_a_backdoor()](tests/backdoor.sol#L4-L6) allows anyone to destruct the contract\n", + "check": "suicidal", + "impact": "High", + "confidence": "High" } ] } diff --git a/tests/expected_json/backdoor.suicidal.txt b/tests/expected_json/backdoor.suicidal.txt index eefe0e4bf..80a385db6 100644 --- a/tests/expected_json/backdoor.suicidal.txt +++ b/tests/expected_json/backdoor.suicidal.txt @@ -1,5 +1,5 @@ -INFO:Detectors: + C.i_am_a_backdoor() (tests/backdoor.sol#4-6) allows anyone to destruct the contract Reference: https://github.com/crytic/slither/wiki/Detector-Documentation#suicidal +tests/backdoor.sol analyzed (1 contracts with 1 detectors), 1 result(s) found INFO:Slither:/home/travis/build/crytic/slither/scripts/../tests/expected_json/backdoor.suicidal.json exists already, the overwrite is prevented -INFO:Slither:tests/backdoor.sol analyzed (1 contracts), 1 result(s) found diff --git a/tests/expected_json/const_state_variables.constable-states.json b/tests/expected_json/const_state_variables.constable-states.json index 60aeaa59b..5864c1e07 100644 --- a/tests/expected_json/const_state_variables.constable-states.json +++ b/tests/expected_json/const_state_variables.constable-states.json @@ -4,10 +4,6 @@ "results": { "detectors": [ { - "check": "constable-states", - "impact": "Optimization", - "confidence": "High", - "description": "A.myFriendsAddress should be constant (tests/const_state_variables.sol#7)\n", "elements": [ { "type": "variable", @@ -64,13 +60,14 @@ } } } - ] - }, - { + ], + "description": "A.myFriendsAddress (tests/const_state_variables.sol#7) should be constant\n", + "markdown": "[A.myFriendsAddress](tests/const_state_variables.sol#L7) should be constant\n", "check": "constable-states", "impact": "Optimization", - "confidence": "High", - "description": "A.test should be constant (tests/const_state_variables.sol#10)\n", + "confidence": "High" + }, + { "elements": [ { "type": "variable", @@ -127,13 +124,14 @@ } } } - ] - }, - { + ], + "description": "A.test (tests/const_state_variables.sol#10) should be constant\n", + "markdown": "[A.test](tests/const_state_variables.sol#L10) should be constant\n", "check": "constable-states", "impact": "Optimization", - "confidence": "High", - "description": "A.text2 should be constant (tests/const_state_variables.sol#14)\n", + "confidence": "High" + }, + { "elements": [ { "type": "variable", @@ -190,13 +188,14 @@ } } } - ] - }, - { + ], + "description": "A.text2 (tests/const_state_variables.sol#14) should be constant\n", + "markdown": "[A.text2](tests/const_state_variables.sol#L14) should be constant\n", "check": "constable-states", "impact": "Optimization", - "confidence": "High", - "description": "B.mySistersAddress should be constant (tests/const_state_variables.sol#26)\n", + "confidence": "High" + }, + { "elements": [ { "type": "variable", @@ -249,13 +248,14 @@ } } } - ] - }, - { + ], + "description": "B.mySistersAddress (tests/const_state_variables.sol#26) should be constant\n", + "markdown": "[B.mySistersAddress](tests/const_state_variables.sol#L26) should be constant\n", "check": "constable-states", "impact": "Optimization", - "confidence": "High", - "description": "MyConc.should_be_constant should be constant (tests/const_state_variables.sol#42)\n", + "confidence": "High" + }, + { "elements": [ { "type": "variable", @@ -308,13 +308,14 @@ } } } - ] - }, - { + ], + "description": "MyConc.should_be_constant (tests/const_state_variables.sol#42) should be constant\n", + "markdown": "[MyConc.should_be_constant](tests/const_state_variables.sol#L42) should be constant\n", "check": "constable-states", "impact": "Optimization", - "confidence": "High", - "description": "MyConc.should_be_constant_2 should be constant (tests/const_state_variables.sol#43)\n", + "confidence": "High" + }, + { "elements": [ { "type": "variable", @@ -367,7 +368,12 @@ } } } - ] + ], + "description": "MyConc.should_be_constant_2 (tests/const_state_variables.sol#43) should be constant\n", + "markdown": "[MyConc.should_be_constant_2](tests/const_state_variables.sol#L43) should be constant\n", + "check": "constable-states", + "impact": "Optimization", + "confidence": "High" } ] } diff --git a/tests/expected_json/const_state_variables.constable-states.txt b/tests/expected_json/const_state_variables.constable-states.txt index d7b05ff8e..27670357d 100644 --- a/tests/expected_json/const_state_variables.constable-states.txt +++ b/tests/expected_json/const_state_variables.constable-states.txt @@ -1,9 +1,9 @@ -INFO:Detectors: -A.myFriendsAddress should be constant (tests/const_state_variables.sol#7) -A.test should be constant (tests/const_state_variables.sol#10) -A.text2 should be constant (tests/const_state_variables.sol#14) -B.mySistersAddress should be constant (tests/const_state_variables.sol#26) -MyConc.should_be_constant should be constant (tests/const_state_variables.sol#42) -MyConc.should_be_constant_2 should be constant (tests/const_state_variables.sol#43) + +A.myFriendsAddress (tests/const_state_variables.sol#7) should be constant +A.test (tests/const_state_variables.sol#10) should be constant +A.text2 (tests/const_state_variables.sol#14) should be constant +B.mySistersAddress (tests/const_state_variables.sol#26) should be constant +MyConc.should_be_constant (tests/const_state_variables.sol#42) should be constant +MyConc.should_be_constant_2 (tests/const_state_variables.sol#43) should be constant Reference: https://github.com/crytic/slither/wiki/Detector-Documentation#state-variables-that-could-be-declared-constant -INFO:Slither:tests/const_state_variables.sol analyzed (3 contracts), 6 result(s) found +tests/const_state_variables.sol analyzed (3 contracts with 1 detectors), 6 result(s) found diff --git a/tests/expected_json/constant-0.5.1.constant-function.json b/tests/expected_json/constant-0.5.1.constant-function.json index 92880bd23..158cd404d 100644 --- a/tests/expected_json/constant-0.5.1.constant-function.json +++ b/tests/expected_json/constant-0.5.1.constant-function.json @@ -4,10 +4,6 @@ "results": { "detectors": [ { - "check": "constant-function", - "impact": "Medium", - "confidence": "Medium", - "description": "Constant.test_assembly_bug() (tests/constant-0.5.1.sol#15-17) is declared view but contains assembly code\n", "elements": [ { "type": "function", @@ -68,9 +64,14 @@ } } ], + "description": "Constant.test_assembly_bug() (tests/constant-0.5.1.sol#15-17) is declared view but contains assembly code\n", + "markdown": "[Constant.test_assembly_bug()](tests/constant-0.5.1.sol#L15-L17) is declared view but contains assembly code\n", "additional_fields": { "contains_assembly": true - } + }, + "check": "constant-function", + "impact": "Medium", + "confidence": "Medium" } ] } diff --git a/tests/expected_json/constant-0.5.1.constant-function.txt b/tests/expected_json/constant-0.5.1.constant-function.txt index 2f308dd12..1fa22f64d 100644 --- a/tests/expected_json/constant-0.5.1.constant-function.txt +++ b/tests/expected_json/constant-0.5.1.constant-function.txt @@ -1,4 +1,4 @@ -INFO:Detectors: + Constant.test_assembly_bug() (tests/constant-0.5.1.sol#15-17) is declared view but contains assembly code Reference: https://github.com/crytic/slither/wiki/Detector-Documentation#constant-functions-changing-the-state -INFO:Slither:tests/constant-0.5.1.sol analyzed (1 contracts), 1 result(s) found +tests/constant-0.5.1.sol analyzed (1 contracts with 1 detectors), 1 result(s) found diff --git a/tests/expected_json/constant.constant-function.json b/tests/expected_json/constant.constant-function.json index cf6f53771..a15771900 100644 --- a/tests/expected_json/constant.constant-function.json +++ b/tests/expected_json/constant.constant-function.json @@ -4,10 +4,6 @@ "results": { "detectors": [ { - "check": "constant-function", - "impact": "Medium", - "confidence": "Medium", - "description": "Constant.test_view_bug() (tests/constant.sol#5-7) is declared view but changes state variables:\n\t- Constant.a\n", "elements": [ { "type": "function", @@ -137,15 +133,16 @@ } } ], + "description": "Constant.test_view_bug() (tests/constant.sol#5-7) is declared view but changes state variables:\n\t- Constant.a (tests/constant.sol#3)\n", + "markdown": "[Constant.test_view_bug()](tests/constant.sol#L5-L7) is declared view but changes state variables:\n\t- [Constant.a](tests/constant.sol#L3)\n", "additional_fields": { "contains_assembly": false - } - }, - { + }, "check": "constant-function", "impact": "Medium", - "confidence": "Medium", - "description": "Constant.test_constant_bug() (tests/constant.sol#9-11) is declared view but changes state variables:\n\t- Constant.a\n", + "confidence": "Medium" + }, + { "elements": [ { "type": "function", @@ -275,15 +272,16 @@ } } ], + "description": "Constant.test_constant_bug() (tests/constant.sol#9-11) is declared view but changes state variables:\n\t- Constant.a (tests/constant.sol#3)\n", + "markdown": "[Constant.test_constant_bug()](tests/constant.sol#L9-L11) is declared view but changes state variables:\n\t- [Constant.a](tests/constant.sol#L3)\n", "additional_fields": { "contains_assembly": false - } - }, - { + }, "check": "constant-function", "impact": "Medium", - "confidence": "Medium", - "description": "Constant.test_assembly_bug() (tests/constant.sol#22-24) is declared view but contains assembly code\n", + "confidence": "Medium" + }, + { "elements": [ { "type": "function", @@ -351,9 +349,14 @@ } } ], + "description": "Constant.test_assembly_bug() (tests/constant.sol#22-24) is declared view but contains assembly code\n", + "markdown": "[Constant.test_assembly_bug()](tests/constant.sol#L22-L24) is declared view but contains assembly code\n", "additional_fields": { "contains_assembly": true - } + }, + "check": "constant-function", + "impact": "Medium", + "confidence": "Medium" } ] } diff --git a/tests/expected_json/constant.constant-function.txt b/tests/expected_json/constant.constant-function.txt index 00eed4577..f2b695232 100644 --- a/tests/expected_json/constant.constant-function.txt +++ b/tests/expected_json/constant.constant-function.txt @@ -1,8 +1,8 @@ -INFO:Detectors: + Constant.test_view_bug() (tests/constant.sol#5-7) is declared view but changes state variables: - - Constant.a + - Constant.a (tests/constant.sol#3) Constant.test_constant_bug() (tests/constant.sol#9-11) is declared view but changes state variables: - - Constant.a + - Constant.a (tests/constant.sol#3) Constant.test_assembly_bug() (tests/constant.sol#22-24) is declared view but contains assembly code Reference: https://github.com/crytic/slither/wiki/Detector-Documentation#constant-functions-changing-the-state -INFO:Slither:tests/constant.sol analyzed (1 contracts), 3 result(s) found +tests/constant.sol analyzed (1 contracts with 1 detectors), 3 result(s) found diff --git a/tests/expected_json/controlled_delegatecall.controlled-delegatecall.json b/tests/expected_json/controlled_delegatecall.controlled-delegatecall.json index 8ee63d9cc..1f2c9bf9c 100644 --- a/tests/expected_json/controlled_delegatecall.controlled-delegatecall.json +++ b/tests/expected_json/controlled_delegatecall.controlled-delegatecall.json @@ -4,11 +4,73 @@ "results": { "detectors": [ { - "check": "controlled-delegatecall", - "impact": "High", - "confidence": "Medium", - "description": "C.bad_delegate_call (tests/controlled_delegatecall.sol#8-11) uses delegatecall to a input-controlled function id\n\t- addr_bad.delegatecall(data) (tests/controlled_delegatecall.sol#10)\n", "elements": [ + { + "type": "function", + "name": "bad_delegate_call", + "source_mapping": { + "start": 101, + "length": 134, + "filename_used": "/home/travis/build/crytic/slither/tests/controlled_delegatecall.sol", + "filename_relative": "tests/controlled_delegatecall.sol", + "filename_absolute": "/home/travis/build/crytic/slither/tests/controlled_delegatecall.sol", + "filename_short": "tests/controlled_delegatecall.sol", + "is_dependency": false, + "lines": [ + 8, + 9, + 10, + 11 + ], + "starting_column": 5, + "ending_column": 6 + }, + "type_specific_fields": { + "parent": { + "type": "contract", + "name": "C", + "source_mapping": { + "start": 0, + "length": 585, + "filename_used": "/home/travis/build/crytic/slither/tests/controlled_delegatecall.sol", + "filename_relative": "tests/controlled_delegatecall.sol", + "filename_absolute": "/home/travis/build/crytic/slither/tests/controlled_delegatecall.sol", + "filename_short": "tests/controlled_delegatecall.sol", + "is_dependency": false, + "lines": [ + 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 + ], + "starting_column": 1, + "ending_column": 2 + } + }, + "signature": "bad_delegate_call(bytes)" + } + }, { "type": "node", "name": "addr_bad.delegatecall(data)", @@ -94,23 +156,31 @@ } } } - }, + } + ], + "description": "C.bad_delegate_call(bytes) (tests/controlled_delegatecall.sol#8-11) uses delegatecall to a input-controlled function id\n\t- addr_bad.delegatecall(data) (tests/controlled_delegatecall.sol#10)\n", + "markdown": "[C.bad_delegate_call(bytes)](tests/controlled_delegatecall.sol#L8-L11) uses delegatecall to a input-controlled function id\n\t- [addr_bad.delegatecall(data)](tests/controlled_delegatecall.sol#L10)\n", + "check": "controlled-delegatecall", + "impact": "High", + "confidence": "Medium" + }, + { + "elements": [ { "type": "function", - "name": "bad_delegate_call", + "name": "bad_delegate_call2", "source_mapping": { - "start": 101, - "length": 134, + "start": 337, + "length": 118, "filename_used": "/home/travis/build/crytic/slither/tests/controlled_delegatecall.sol", "filename_relative": "tests/controlled_delegatecall.sol", "filename_absolute": "/home/travis/build/crytic/slither/tests/controlled_delegatecall.sol", "filename_short": "tests/controlled_delegatecall.sol", "is_dependency": false, "lines": [ - 8, - 9, - 10, - 11 + 18, + 19, + 20 ], "starting_column": 5, "ending_column": 6 @@ -158,17 +228,9 @@ "ending_column": 2 } }, - "signature": "bad_delegate_call(bytes)" + "signature": "bad_delegate_call2(bytes)" } - } - ] - }, - { - "check": "controlled-delegatecall", - "impact": "High", - "confidence": "Medium", - "description": "C.bad_delegate_call2 (tests/controlled_delegatecall.sol#18-20) uses delegatecall to a input-controlled function id\n\t- addr_bad.delegatecall(abi.encode(func_id,data)) (tests/controlled_delegatecall.sol#19)\n", - "elements": [ + }, { "type": "node", "name": "addr_bad.delegatecall(abi.encode(func_id,data))", @@ -253,73 +315,13 @@ } } } - }, - { - "type": "function", - "name": "bad_delegate_call2", - "source_mapping": { - "start": 337, - "length": 118, - "filename_used": "/home/travis/build/crytic/slither/tests/controlled_delegatecall.sol", - "filename_relative": "tests/controlled_delegatecall.sol", - "filename_absolute": "/home/travis/build/crytic/slither/tests/controlled_delegatecall.sol", - "filename_short": "tests/controlled_delegatecall.sol", - "is_dependency": false, - "lines": [ - 18, - 19, - 20 - ], - "starting_column": 5, - "ending_column": 6 - }, - "type_specific_fields": { - "parent": { - "type": "contract", - "name": "C", - "source_mapping": { - "start": 0, - "length": 585, - "filename_used": "/home/travis/build/crytic/slither/tests/controlled_delegatecall.sol", - "filename_relative": "tests/controlled_delegatecall.sol", - "filename_absolute": "/home/travis/build/crytic/slither/tests/controlled_delegatecall.sol", - "filename_short": "tests/controlled_delegatecall.sol", - "is_dependency": false, - "lines": [ - 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 - ], - "starting_column": 1, - "ending_column": 2 - } - }, - "signature": "bad_delegate_call2(bytes)" - } } - ] + ], + "description": "C.bad_delegate_call2(bytes) (tests/controlled_delegatecall.sol#18-20) uses delegatecall to a input-controlled function id\n\t- addr_bad.delegatecall(abi.encode(func_id,data)) (tests/controlled_delegatecall.sol#19)\n", + "markdown": "[C.bad_delegate_call2(bytes)](tests/controlled_delegatecall.sol#L18-L20) uses delegatecall to a input-controlled function id\n\t- [addr_bad.delegatecall(abi.encode(func_id,data))](tests/controlled_delegatecall.sol#L19)\n", + "check": "controlled-delegatecall", + "impact": "High", + "confidence": "Medium" } ] } diff --git a/tests/expected_json/controlled_delegatecall.controlled-delegatecall.txt b/tests/expected_json/controlled_delegatecall.controlled-delegatecall.txt index c97185377..ade36ba5b 100644 --- a/tests/expected_json/controlled_delegatecall.controlled-delegatecall.txt +++ b/tests/expected_json/controlled_delegatecall.controlled-delegatecall.txt @@ -1,7 +1,7 @@ -INFO:Detectors: -C.bad_delegate_call (tests/controlled_delegatecall.sol#8-11) uses delegatecall to a input-controlled function id + +C.bad_delegate_call(bytes) (tests/controlled_delegatecall.sol#8-11) uses delegatecall to a input-controlled function id - addr_bad.delegatecall(data) (tests/controlled_delegatecall.sol#10) -C.bad_delegate_call2 (tests/controlled_delegatecall.sol#18-20) uses delegatecall to a input-controlled function id +C.bad_delegate_call2(bytes) (tests/controlled_delegatecall.sol#18-20) uses delegatecall to a input-controlled function id - addr_bad.delegatecall(abi.encode(func_id,data)) (tests/controlled_delegatecall.sol#19) Reference: https://github.com/crytic/slither/wiki/Detector-Documentation#controlled-delegatecall -INFO:Slither:tests/controlled_delegatecall.sol analyzed (1 contracts), 2 result(s) found +tests/controlled_delegatecall.sol analyzed (1 contracts with 1 detectors), 2 result(s) found diff --git a/tests/expected_json/deprecated_calls.deprecated-standards.json b/tests/expected_json/deprecated_calls.deprecated-standards.json index 9680b948d..c318914ac 100644 --- a/tests/expected_json/deprecated_calls.deprecated-standards.json +++ b/tests/expected_json/deprecated_calls.deprecated-standards.json @@ -4,10 +4,6 @@ "results": { "detectors": [ { - "check": "deprecated-standards", - "impact": "Informational", - "confidence": "High", - "description": "Deprecated standard detected @ tests/deprecated_calls.sol#2:\n\t- Usage of \"block.blockhash()\" should be replaced with \"blockhash()\"\n", "elements": [ { "type": "variable", @@ -73,13 +69,14 @@ } } } - ] - }, - { + ], + "description": "Deprecated standard detected ContractWithDeprecatedReferences.globalBlockHash (tests/deprecated_calls.sol#2):\n\t- Usage of \"block.blockhash()\" should be replaced with \"blockhash()\"\n", + "markdown": "Deprecated standard detected [ContractWithDeprecatedReferences.globalBlockHash](tests/deprecated_calls.sol#L2):\n\t- Usage of \"block.blockhash()\" should be replaced with \"blockhash()\"\n", "check": "deprecated-standards", "impact": "Informational", - "confidence": "High", - "description": "Deprecated standard detected @ tests/deprecated_calls.sol#7:\n\t- Usage of \"msg.gas\" should be replaced with \"gasleft()\"\n", + "confidence": "High" + }, + { "elements": [ { "type": "node", @@ -172,13 +169,14 @@ } } } - ] - }, - { + ], + "description": "Deprecated standard detected msg.gas == msg.value (tests/deprecated_calls.sol#7):\n\t- Usage of \"msg.gas\" should be replaced with \"gasleft()\"\n", + "markdown": "Deprecated standard detected [msg.gas == msg.value](tests/deprecated_calls.sol#L7):\n\t- Usage of \"msg.gas\" should be replaced with \"gasleft()\"\n", "check": "deprecated-standards", "impact": "Informational", - "confidence": "High", - "description": "Deprecated standard detected @ tests/deprecated_calls.sol#9:\n\t- Usage of \"throw\" should be replaced with \"revert()\"\n", + "confidence": "High" + }, + { "elements": [ { "type": "node", @@ -271,13 +269,14 @@ } } } - ] - }, - { + ], + "description": "Deprecated standard detected THROW None (tests/deprecated_calls.sol#9):\n\t- Usage of \"throw\" should be replaced with \"revert()\"\n", + "markdown": "Deprecated standard detected [THROW None](tests/deprecated_calls.sol#L9):\n\t- Usage of \"throw\" should be replaced with \"revert()\"\n", "check": "deprecated-standards", "impact": "Informational", - "confidence": "High", - "description": "Deprecated standard detected @ tests/deprecated_calls.sol#16:\n\t- Usage of \"sha3()\" should be replaced with \"keccak256()\"\n", + "confidence": "High" + }, + { "elements": [ { "type": "node", @@ -376,13 +375,14 @@ } } } - ] - }, - { + ], + "description": "Deprecated standard detected sha3Result = sha3()(test deprecated sha3 usage) (tests/deprecated_calls.sol#16):\n\t- Usage of \"sha3()\" should be replaced with \"keccak256()\"\n", + "markdown": "Deprecated standard detected [sha3Result = sha3()(test deprecated sha3 usage)](tests/deprecated_calls.sol#L16):\n\t- Usage of \"sha3()\" should be replaced with \"keccak256()\"\n", "check": "deprecated-standards", "impact": "Informational", - "confidence": "High", - "description": "Deprecated standard detected @ tests/deprecated_calls.sol#19:\n\t- Usage of \"block.blockhash()\" should be replaced with \"blockhash()\"\n", + "confidence": "High" + }, + { "elements": [ { "type": "node", @@ -481,13 +481,14 @@ } } } - ] - }, - { + ], + "description": "Deprecated standard detected blockHashResult = block.blockhash(0) (tests/deprecated_calls.sol#19):\n\t- Usage of \"block.blockhash()\" should be replaced with \"blockhash()\"\n", + "markdown": "Deprecated standard detected [blockHashResult = block.blockhash(0)](tests/deprecated_calls.sol#L19):\n\t- Usage of \"block.blockhash()\" should be replaced with \"blockhash()\"\n", "check": "deprecated-standards", "impact": "Informational", - "confidence": "High", - "description": "Deprecated standard detected @ tests/deprecated_calls.sol#22:\n\t- Usage of \"callcode\" should be replaced with \"delegatecall\"\n", + "confidence": "High" + }, + { "elements": [ { "type": "node", @@ -586,13 +587,14 @@ } } } - ] - }, - { + ], + "description": "Deprecated standard detected address(this).callcode() (tests/deprecated_calls.sol#22):\n\t- Usage of \"callcode\" should be replaced with \"delegatecall\"\n", + "markdown": "Deprecated standard detected [address(this).callcode()](tests/deprecated_calls.sol#L22):\n\t- Usage of \"callcode\" should be replaced with \"delegatecall\"\n", "check": "deprecated-standards", "impact": "Informational", - "confidence": "High", - "description": "Deprecated standard detected @ tests/deprecated_calls.sol#25:\n\t- Usage of \"suicide()\" should be replaced with \"selfdestruct()\"\n", + "confidence": "High" + }, + { "elements": [ { "type": "node", @@ -691,13 +693,14 @@ } } } - ] - }, - { + ], + "description": "Deprecated standard detected suicide(address)(address(0)) (tests/deprecated_calls.sol#25):\n\t- Usage of \"suicide()\" should be replaced with \"selfdestruct()\"\n", + "markdown": "Deprecated standard detected [suicide(address)(address(0))](tests/deprecated_calls.sol#L25):\n\t- Usage of \"suicide()\" should be replaced with \"selfdestruct()\"\n", "check": "deprecated-standards", "impact": "Informational", - "confidence": "High", - "description": "Deprecated standard detected @ tests/deprecated_calls.sol#2:\n\t- Usage of \"block.blockhash()\" should be replaced with \"blockhash()\"\n", + "confidence": "High" + }, + { "elements": [ { "type": "node", @@ -810,7 +813,12 @@ } } } - ] + ], + "description": "Deprecated standard detected globalBlockHash = block.blockhash(0) (tests/deprecated_calls.sol#2):\n\t- Usage of \"block.blockhash()\" should be replaced with \"blockhash()\"\n", + "markdown": "Deprecated standard detected [globalBlockHash = block.blockhash(0)](tests/deprecated_calls.sol#L2):\n\t- Usage of \"block.blockhash()\" should be replaced with \"blockhash()\"\n", + "check": "deprecated-standards", + "impact": "Informational", + "confidence": "High" } ] } diff --git a/tests/expected_json/deprecated_calls.deprecated-standards.txt b/tests/expected_json/deprecated_calls.deprecated-standards.txt index 63d07a08d..a8180ef3b 100644 --- a/tests/expected_json/deprecated_calls.deprecated-standards.txt +++ b/tests/expected_json/deprecated_calls.deprecated-standards.txt @@ -1,19 +1,19 @@ -INFO:Detectors: -Deprecated standard detected @ tests/deprecated_calls.sol#2: + +Deprecated standard detected ContractWithDeprecatedReferences.globalBlockHash (tests/deprecated_calls.sol#2): - Usage of "block.blockhash()" should be replaced with "blockhash()" -Deprecated standard detected @ tests/deprecated_calls.sol#7: +Deprecated standard detected msg.gas == msg.value (tests/deprecated_calls.sol#7): - Usage of "msg.gas" should be replaced with "gasleft()" -Deprecated standard detected @ tests/deprecated_calls.sol#9: +Deprecated standard detected THROW None (tests/deprecated_calls.sol#9): - Usage of "throw" should be replaced with "revert()" -Deprecated standard detected @ tests/deprecated_calls.sol#16: +Deprecated standard detected sha3Result = sha3()(test deprecated sha3 usage) (tests/deprecated_calls.sol#16): - Usage of "sha3()" should be replaced with "keccak256()" -Deprecated standard detected @ tests/deprecated_calls.sol#19: +Deprecated standard detected blockHashResult = block.blockhash(0) (tests/deprecated_calls.sol#19): - Usage of "block.blockhash()" should be replaced with "blockhash()" -Deprecated standard detected @ tests/deprecated_calls.sol#22: +Deprecated standard detected address(this).callcode() (tests/deprecated_calls.sol#22): - Usage of "callcode" should be replaced with "delegatecall" -Deprecated standard detected @ tests/deprecated_calls.sol#25: +Deprecated standard detected suicide(address)(address(0)) (tests/deprecated_calls.sol#25): - Usage of "suicide()" should be replaced with "selfdestruct()" -Deprecated standard detected @ tests/deprecated_calls.sol#2: +Deprecated standard detected globalBlockHash = block.blockhash(0) (tests/deprecated_calls.sol#2): - Usage of "block.blockhash()" should be replaced with "blockhash()" Reference: https://github.com/crytic/slither/wiki/Detector-Documentation#deprecated-standards -INFO:Slither:tests/deprecated_calls.sol analyzed (1 contracts), 8 result(s) found +tests/deprecated_calls.sol analyzed (1 contracts with 1 detectors), 8 result(s) found diff --git a/tests/expected_json/erc20_indexed.erc20-indexed.json b/tests/expected_json/erc20_indexed.erc20-indexed.json index b6d7aafcb..3aeaf30a9 100644 --- a/tests/expected_json/erc20_indexed.erc20-indexed.json +++ b/tests/expected_json/erc20_indexed.erc20-indexed.json @@ -4,10 +4,6 @@ "results": { "detectors": [ { - "check": "erc20-indexed", - "impact": "Informational", - "confidence": "High", - "description": "ERC20 event IERC20Bad.Transfer (tests/erc20_indexed.sol#19) does not index parameter 'from'\n", "elements": [ { "type": "event", @@ -60,13 +56,14 @@ "parameter_name": "from" } } - ] - }, - { + ], + "description": "ERC20 event IERC20BadTransfer(address,address,uint256) (tests/erc20_indexed.sol#19)does not index parameter from\n", + "markdown": "ERC20 event [IERC20BadTransfer(address,address,uint256)](tests/erc20_indexed.sol#L19)does not index parameter from\n", "check": "erc20-indexed", "impact": "Informational", - "confidence": "High", - "description": "ERC20 event IERC20Bad.Transfer (tests/erc20_indexed.sol#19) does not index parameter 'to'\n", + "confidence": "High" + }, + { "elements": [ { "type": "event", @@ -119,13 +116,14 @@ "parameter_name": "to" } } - ] - }, - { + ], + "description": "ERC20 event IERC20BadTransfer(address,address,uint256) (tests/erc20_indexed.sol#19)does not index parameter to\n", + "markdown": "ERC20 event [IERC20BadTransfer(address,address,uint256)](tests/erc20_indexed.sol#L19)does not index parameter to\n", "check": "erc20-indexed", "impact": "Informational", - "confidence": "High", - "description": "ERC20 event IERC20Bad.Approval (tests/erc20_indexed.sol#20) does not index parameter 'owner'\n", + "confidence": "High" + }, + { "elements": [ { "type": "event", @@ -178,13 +176,14 @@ "parameter_name": "owner" } } - ] - }, - { + ], + "description": "ERC20 event IERC20BadApproval(address,address,uint256) (tests/erc20_indexed.sol#20)does not index parameter owner\n", + "markdown": "ERC20 event [IERC20BadApproval(address,address,uint256)](tests/erc20_indexed.sol#L20)does not index parameter owner\n", "check": "erc20-indexed", "impact": "Informational", - "confidence": "High", - "description": "ERC20 event IERC20Bad.Approval (tests/erc20_indexed.sol#20) does not index parameter 'spender'\n", + "confidence": "High" + }, + { "elements": [ { "type": "event", @@ -237,7 +236,12 @@ "parameter_name": "spender" } } - ] + ], + "description": "ERC20 event IERC20BadApproval(address,address,uint256) (tests/erc20_indexed.sol#20)does not index parameter spender\n", + "markdown": "ERC20 event [IERC20BadApproval(address,address,uint256)](tests/erc20_indexed.sol#L20)does not index parameter spender\n", + "check": "erc20-indexed", + "impact": "Informational", + "confidence": "High" } ] } diff --git a/tests/expected_json/erc20_indexed.erc20-indexed.txt b/tests/expected_json/erc20_indexed.erc20-indexed.txt index db0314cbd..4f7728022 100644 --- a/tests/expected_json/erc20_indexed.erc20-indexed.txt +++ b/tests/expected_json/erc20_indexed.erc20-indexed.txt @@ -1,7 +1,7 @@ -INFO:Detectors: -ERC20 event IERC20Bad.Transfer (tests/erc20_indexed.sol#19) does not index parameter 'from' -ERC20 event IERC20Bad.Transfer (tests/erc20_indexed.sol#19) does not index parameter 'to' -ERC20 event IERC20Bad.Approval (tests/erc20_indexed.sol#20) does not index parameter 'owner' -ERC20 event IERC20Bad.Approval (tests/erc20_indexed.sol#20) does not index parameter 'spender' + +ERC20 event IERC20BadTransfer(address,address,uint256) (tests/erc20_indexed.sol#19)does not index parameter from +ERC20 event IERC20BadTransfer(address,address,uint256) (tests/erc20_indexed.sol#19)does not index parameter to +ERC20 event IERC20BadApproval(address,address,uint256) (tests/erc20_indexed.sol#20)does not index parameter owner +ERC20 event IERC20BadApproval(address,address,uint256) (tests/erc20_indexed.sol#20)does not index parameter spender Reference: https://github.com/crytic/slither/wiki/Detector-Documentation#unindexed-erc20-event-parameters -INFO:Slither:tests/erc20_indexed.sol analyzed (3 contracts), 4 result(s) found +tests/erc20_indexed.sol analyzed (3 contracts with 1 detectors), 4 result(s) found diff --git a/tests/expected_json/external_function.external-function.json b/tests/expected_json/external_function.external-function.json index 026c45140..2e1fa666c 100644 --- a/tests/expected_json/external_function.external-function.json +++ b/tests/expected_json/external_function.external-function.json @@ -4,10 +4,6 @@ "results": { "detectors": [ { - "check": "external-function", - "impact": "Optimization", - "confidence": "High", - "description": "funcNotCalled3() should be declared external:\n\t- ContractWithFunctionNotCalled.funcNotCalled3() (tests/external_function.sol#13-15)\n", "elements": [ { "type": "function", @@ -68,13 +64,14 @@ "signature": "funcNotCalled3()" } } - ] - }, - { + ], + "description": "funcNotCalled3() should be declared external:\n\t- ContractWithFunctionNotCalled.funcNotCalled3() (tests/external_function.sol#13-15)\n", + "markdown": "funcNotCalled3() should be declared external:\n\t- [ContractWithFunctionNotCalled.funcNotCalled3()](tests/external_function.sol#L13-L15)\n", "check": "external-function", "impact": "Optimization", - "confidence": "High", - "description": "funcNotCalled2() should be declared external:\n\t- ContractWithFunctionNotCalled.funcNotCalled2() (tests/external_function.sol#17-19)\n", + "confidence": "High" + }, + { "elements": [ { "type": "function", @@ -135,13 +132,14 @@ "signature": "funcNotCalled2()" } } - ] - }, - { + ], + "description": "funcNotCalled2() should be declared external:\n\t- ContractWithFunctionNotCalled.funcNotCalled2() (tests/external_function.sol#17-19)\n", + "markdown": "funcNotCalled2() should be declared external:\n\t- [ContractWithFunctionNotCalled.funcNotCalled2()](tests/external_function.sol#L17-L19)\n", "check": "external-function", "impact": "Optimization", - "confidence": "High", - "description": "funcNotCalled() should be declared external:\n\t- ContractWithFunctionNotCalled.funcNotCalled() (tests/external_function.sol#21-23)\n", + "confidence": "High" + }, + { "elements": [ { "type": "function", @@ -202,13 +200,14 @@ "signature": "funcNotCalled()" } } - ] - }, - { + ], + "description": "funcNotCalled() should be declared external:\n\t- ContractWithFunctionNotCalled.funcNotCalled() (tests/external_function.sol#21-23)\n", + "markdown": "funcNotCalled() should be declared external:\n\t- [ContractWithFunctionNotCalled.funcNotCalled()](tests/external_function.sol#L21-L23)\n", "check": "external-function", "impact": "Optimization", - "confidence": "High", - "description": "funcNotCalled() should be declared external:\n\t- ContractWithFunctionNotCalled2.funcNotCalled() (tests/external_function.sol#32-39)\n", + "confidence": "High" + }, + { "elements": [ { "type": "function", @@ -265,13 +264,14 @@ "signature": "funcNotCalled()" } } - ] - }, - { + ], + "description": "funcNotCalled() should be declared external:\n\t- ContractWithFunctionNotCalled2.funcNotCalled() (tests/external_function.sol#32-39)\n", + "markdown": "funcNotCalled() should be declared external:\n\t- [ContractWithFunctionNotCalled2.funcNotCalled()](tests/external_function.sol#L32-L39)\n", "check": "external-function", "impact": "Optimization", - "confidence": "High", - "description": "parameter_read_ok_for_external(uint256) should be declared external:\n\t- FunctionParameterWrite.parameter_read_ok_for_external(uint256) (tests/external_function.sol#74-76)\n", + "confidence": "High" + }, + { "elements": [ { "type": "function", @@ -324,7 +324,12 @@ "signature": "parameter_read_ok_for_external(uint256)" } } - ] + ], + "description": "parameter_read_ok_for_external(uint256) should be declared external:\n\t- FunctionParameterWrite.parameter_read_ok_for_external(uint256) (tests/external_function.sol#74-76)\n", + "markdown": "parameter_read_ok_for_external(uint256) should be declared external:\n\t- [FunctionParameterWrite.parameter_read_ok_for_external(uint256)](tests/external_function.sol#L74-L76)\n", + "check": "external-function", + "impact": "Optimization", + "confidence": "High" } ] } diff --git a/tests/expected_json/incorrect_equality.incorrect-equality.json b/tests/expected_json/incorrect_equality.incorrect-equality.json index 3802e83b6..bf26037cf 100644 --- a/tests/expected_json/incorrect_equality.incorrect-equality.json +++ b/tests/expected_json/incorrect_equality.incorrect-equality.json @@ -4,11 +4,66 @@ "results": { "detectors": [ { - "check": "incorrect-equality", - "impact": "Medium", - "confidence": "High", - "description": "ERC20TestBalance.bad0(ERC20Function) (tests/incorrect_equality.sol#21-23) uses a dangerous strict equality:\n\t- require(bool)(erc.balanceOf(address(this)) == 10)\n", "elements": [ + { + "type": "function", + "name": "bad0", + "source_mapping": { + "start": 404, + "length": 101, + "filename_used": "/home/travis/build/crytic/slither/tests/incorrect_equality.sol", + "filename_relative": "tests/incorrect_equality.sol", + "filename_absolute": "/home/travis/build/crytic/slither/tests/incorrect_equality.sol", + "filename_short": "tests/incorrect_equality.sol", + "is_dependency": false, + "lines": [ + 21, + 22, + 23 + ], + "starting_column": 5, + "ending_column": 6 + }, + "type_specific_fields": { + "parent": { + "type": "contract", + "name": "ERC20TestBalance", + "source_mapping": { + "start": 165, + "length": 445, + "filename_used": "/home/travis/build/crytic/slither/tests/incorrect_equality.sol", + "filename_relative": "tests/incorrect_equality.sol", + "filename_absolute": "/home/travis/build/crytic/slither/tests/incorrect_equality.sol", + "filename_short": "tests/incorrect_equality.sol", + "is_dependency": false, + "lines": [ + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28 + ], + "starting_column": 1, + "ending_column": 2 + } + }, + "signature": "bad0(ERC20Function)" + } + }, { "type": "node", "name": "require(bool)(erc.balanceOf(address(this)) == 10)", @@ -87,22 +142,31 @@ } } } - }, + } + ], + "description": "ERC20TestBalance.bad0(ERC20Function) (tests/incorrect_equality.sol#21-23) uses a dangerous strict equality:\n\t- require(bool)(erc.balanceOf(address(this)) == 10) (tests/incorrect_equality.sol#22)\n", + "markdown": "[ERC20TestBalance.bad0(ERC20Function)](tests/incorrect_equality.sol#L21-L23) uses a dangerous strict equality:\n\t- [require(bool)(erc.balanceOf(address(this)) == 10)](tests/incorrect_equality.sol#L22)\n", + "check": "incorrect-equality", + "impact": "Medium", + "confidence": "High" + }, + { + "elements": [ { "type": "function", - "name": "bad0", + "name": "bad1", "source_mapping": { - "start": 404, - "length": 101, + "start": 511, + "length": 97, "filename_used": "/home/travis/build/crytic/slither/tests/incorrect_equality.sol", "filename_relative": "tests/incorrect_equality.sol", "filename_absolute": "/home/travis/build/crytic/slither/tests/incorrect_equality.sol", "filename_short": "tests/incorrect_equality.sol", "is_dependency": false, "lines": [ - 21, - 22, - 23 + 25, + 26, + 27 ], "starting_column": 5, "ending_column": 6 @@ -144,17 +208,9 @@ "ending_column": 2 } }, - "signature": "bad0(ERC20Function)" + "signature": "bad1(ERC20Variable)" } - } - ] - }, - { - "check": "incorrect-equality", - "impact": "Medium", - "confidence": "High", - "description": "ERC20TestBalance.bad1(ERC20Variable) (tests/incorrect_equality.sol#25-27) uses a dangerous strict equality:\n\t- require(bool)(erc.balanceOf(msg.sender) == 10)\n", - "elements": [ + }, { "type": "node", "name": "require(bool)(erc.balanceOf(msg.sender) == 10)", @@ -233,22 +289,32 @@ } } } - }, + } + ], + "description": "ERC20TestBalance.bad1(ERC20Variable) (tests/incorrect_equality.sol#25-27) uses a dangerous strict equality:\n\t- require(bool)(erc.balanceOf(msg.sender) == 10) (tests/incorrect_equality.sol#26)\n", + "markdown": "[ERC20TestBalance.bad1(ERC20Variable)](tests/incorrect_equality.sol#L25-L27) uses a dangerous strict equality:\n\t- [require(bool)(erc.balanceOf(msg.sender) == 10)](tests/incorrect_equality.sol#L26)\n", + "check": "incorrect-equality", + "impact": "Medium", + "confidence": "High" + }, + { + "elements": [ { "type": "function", - "name": "bad1", + "name": "bad0", "source_mapping": { - "start": 511, - "length": 97, + "start": 648, + "length": 133, "filename_used": "/home/travis/build/crytic/slither/tests/incorrect_equality.sol", "filename_relative": "tests/incorrect_equality.sol", "filename_absolute": "/home/travis/build/crytic/slither/tests/incorrect_equality.sol", "filename_short": "tests/incorrect_equality.sol", "is_dependency": false, "lines": [ - 25, - 26, - 27 + 32, + 33, + 34, + 35 ], "starting_column": 5, "ending_column": 6 @@ -256,51 +322,92 @@ "type_specific_fields": { "parent": { "type": "contract", - "name": "ERC20TestBalance", + "name": "TestContractBalance", "source_mapping": { - "start": 165, - "length": 445, + "start": 612, + "length": 1754, "filename_used": "/home/travis/build/crytic/slither/tests/incorrect_equality.sol", "filename_relative": "tests/incorrect_equality.sol", "filename_absolute": "/home/travis/build/crytic/slither/tests/incorrect_equality.sol", "filename_short": "tests/incorrect_equality.sol", "is_dependency": false, "lines": [ - 10, - 11, - 12, - 13, - 14, - 15, - 16, - 17, - 18, - 19, - 20, - 21, - 22, - 23, - 24, - 25, - 26, - 27, - 28 + 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 ], "starting_column": 1, "ending_column": 2 } }, - "signature": "bad1(ERC20Variable)" + "signature": "bad0()" } - } - ] - }, - { - "check": "incorrect-equality", - "impact": "Medium", - "confidence": "High", - "description": "TestContractBalance.bad0() (tests/incorrect_equality.sol#32-35) uses a dangerous strict equality:\n\t- require(bool)(address(address(this)).balance == 10000000000000000000)\n", - "elements": [ + }, { "type": "node", "name": "require(bool)(address(address(this)).balance == 10000000000000000000)", @@ -429,12 +536,21 @@ } } } - }, + } + ], + "description": "TestContractBalance.bad0() (tests/incorrect_equality.sol#32-35) uses a dangerous strict equality:\n\t- require(bool)(address(address(this)).balance == 10000000000000000000) (tests/incorrect_equality.sol#33)\n", + "markdown": "[TestContractBalance.bad0()](tests/incorrect_equality.sol#L32-L35) uses a dangerous strict equality:\n\t- [require(bool)(address(address(this)).balance == 10000000000000000000)](tests/incorrect_equality.sol#L33)\n", + "check": "incorrect-equality", + "impact": "Medium", + "confidence": "High" + }, + { + "elements": [ { "type": "function", - "name": "bad0", + "name": "bad1", "source_mapping": { - "start": 648, + "start": 787, "length": 133, "filename_used": "/home/travis/build/crytic/slither/tests/incorrect_equality.sol", "filename_relative": "tests/incorrect_equality.sol", @@ -442,10 +558,10 @@ "filename_short": "tests/incorrect_equality.sol", "is_dependency": false, "lines": [ - 32, - 33, - 34, - 35 + 37, + 38, + 39, + 40 ], "starting_column": 5, "ending_column": 6 @@ -536,17 +652,9 @@ "ending_column": 2 } }, - "signature": "bad0()" + "signature": "bad1()" } - } - ] - }, - { - "check": "incorrect-equality", - "impact": "Medium", - "confidence": "High", - "description": "TestContractBalance.bad1() (tests/incorrect_equality.sol#37-40) uses a dangerous strict equality:\n\t- require(bool)(10000000000000000000 == address(address(this)).balance)\n", - "elements": [ + }, { "type": "node", "name": "require(bool)(10000000000000000000 == address(address(this)).balance)", @@ -675,23 +783,32 @@ } } } - }, + } + ], + "description": "TestContractBalance.bad1() (tests/incorrect_equality.sol#37-40) uses a dangerous strict equality:\n\t- require(bool)(10000000000000000000 == address(address(this)).balance) (tests/incorrect_equality.sol#38)\n", + "markdown": "[TestContractBalance.bad1()](tests/incorrect_equality.sol#L37-L40) uses a dangerous strict equality:\n\t- [require(bool)(10000000000000000000 == address(address(this)).balance)](tests/incorrect_equality.sol#L38)\n", + "check": "incorrect-equality", + "impact": "Medium", + "confidence": "High" + }, + { + "elements": [ { "type": "function", - "name": "bad1", + "name": "bad2", "source_mapping": { - "start": 787, - "length": 133, + "start": 926, + "length": 124, "filename_used": "/home/travis/build/crytic/slither/tests/incorrect_equality.sol", "filename_relative": "tests/incorrect_equality.sol", "filename_absolute": "/home/travis/build/crytic/slither/tests/incorrect_equality.sol", "filename_short": "tests/incorrect_equality.sol", "is_dependency": false, "lines": [ - 37, - 38, - 39, - 40 + 42, + 43, + 44, + 45 ], "starting_column": 5, "ending_column": 6 @@ -782,17 +899,9 @@ "ending_column": 2 } }, - "signature": "bad1()" + "signature": "bad2()" } - } - ] - }, - { - "check": "incorrect-equality", - "impact": "Medium", - "confidence": "High", - "description": "TestContractBalance.bad2() (tests/incorrect_equality.sol#42-45) uses a dangerous strict equality:\n\t- require(bool)(address(this).balance == 10000000000000000000)\n", - "elements": [ + }, { "type": "node", "name": "require(bool)(address(this).balance == 10000000000000000000)", @@ -921,12 +1030,21 @@ } } } - }, + } + ], + "description": "TestContractBalance.bad2() (tests/incorrect_equality.sol#42-45) uses a dangerous strict equality:\n\t- require(bool)(address(this).balance == 10000000000000000000) (tests/incorrect_equality.sol#43)\n", + "markdown": "[TestContractBalance.bad2()](tests/incorrect_equality.sol#L42-L45) uses a dangerous strict equality:\n\t- [require(bool)(address(this).balance == 10000000000000000000)](tests/incorrect_equality.sol#L43)\n", + "check": "incorrect-equality", + "impact": "Medium", + "confidence": "High" + }, + { + "elements": [ { "type": "function", - "name": "bad2", + "name": "bad3", "source_mapping": { - "start": 926, + "start": 1056, "length": 124, "filename_used": "/home/travis/build/crytic/slither/tests/incorrect_equality.sol", "filename_relative": "tests/incorrect_equality.sol", @@ -934,10 +1052,10 @@ "filename_short": "tests/incorrect_equality.sol", "is_dependency": false, "lines": [ - 42, - 43, - 44, - 45 + 47, + 48, + 49, + 50 ], "starting_column": 5, "ending_column": 6 @@ -1028,17 +1146,9 @@ "ending_column": 2 } }, - "signature": "bad2()" + "signature": "bad3()" } - } - ] - }, - { - "check": "incorrect-equality", - "impact": "Medium", - "confidence": "High", - "description": "TestContractBalance.bad3() (tests/incorrect_equality.sol#47-50) uses a dangerous strict equality:\n\t- require(bool)(10000000000000000000 == address(this).balance)\n", - "elements": [ + }, { "type": "node", "name": "require(bool)(10000000000000000000 == address(this).balance)", @@ -1167,23 +1277,34 @@ } } } - }, + } + ], + "description": "TestContractBalance.bad3() (tests/incorrect_equality.sol#47-50) uses a dangerous strict equality:\n\t- require(bool)(10000000000000000000 == address(this).balance) (tests/incorrect_equality.sol#48)\n", + "markdown": "[TestContractBalance.bad3()](tests/incorrect_equality.sol#L47-L50) uses a dangerous strict equality:\n\t- [require(bool)(10000000000000000000 == address(this).balance)](tests/incorrect_equality.sol#L48)\n", + "check": "incorrect-equality", + "impact": "Medium", + "confidence": "High" + }, + { + "elements": [ { "type": "function", - "name": "bad3", + "name": "bad4", "source_mapping": { - "start": 1056, - "length": 124, + "start": 1186, + "length": 170, "filename_used": "/home/travis/build/crytic/slither/tests/incorrect_equality.sol", "filename_relative": "tests/incorrect_equality.sol", "filename_absolute": "/home/travis/build/crytic/slither/tests/incorrect_equality.sol", "filename_short": "tests/incorrect_equality.sol", "is_dependency": false, "lines": [ - 47, - 48, - 49, - 50 + 52, + 53, + 54, + 55, + 56, + 57 ], "starting_column": 5, "ending_column": 6 @@ -1274,17 +1395,9 @@ "ending_column": 2 } }, - "signature": "bad3()" + "signature": "bad4()" } - } - ] - }, - { - "check": "incorrect-equality", - "impact": "Medium", - "confidence": "High", - "description": "TestContractBalance.bad4() (tests/incorrect_equality.sol#52-57) uses a dangerous strict equality:\n\t- balance == 10000000000000000000\n", - "elements": [ + }, { "type": "node", "name": "balance == 10000000000000000000", @@ -1415,12 +1528,21 @@ } } } - }, + } + ], + "description": "TestContractBalance.bad4() (tests/incorrect_equality.sol#52-57) uses a dangerous strict equality:\n\t- balance == 10000000000000000000 (tests/incorrect_equality.sol#54)\n", + "markdown": "[TestContractBalance.bad4()](tests/incorrect_equality.sol#L52-L57) uses a dangerous strict equality:\n\t- [balance == 10000000000000000000](tests/incorrect_equality.sol#L54)\n", + "check": "incorrect-equality", + "impact": "Medium", + "confidence": "High" + }, + { + "elements": [ { "type": "function", - "name": "bad4", + "name": "bad5", "source_mapping": { - "start": 1186, + "start": 1362, "length": 170, "filename_used": "/home/travis/build/crytic/slither/tests/incorrect_equality.sol", "filename_relative": "tests/incorrect_equality.sol", @@ -1428,12 +1550,12 @@ "filename_short": "tests/incorrect_equality.sol", "is_dependency": false, "lines": [ - 52, - 53, - 54, - 55, - 56, - 57 + 59, + 60, + 61, + 62, + 63, + 64 ], "starting_column": 5, "ending_column": 6 @@ -1524,17 +1646,9 @@ "ending_column": 2 } }, - "signature": "bad4()" + "signature": "bad5()" } - } - ] - }, - { - "check": "incorrect-equality", - "impact": "Medium", - "confidence": "High", - "description": "TestContractBalance.bad5() (tests/incorrect_equality.sol#59-64) uses a dangerous strict equality:\n\t- 10000000000000000000 == balance\n", - "elements": [ + }, { "type": "node", "name": "10000000000000000000 == balance", @@ -1665,25 +1779,34 @@ } } } - }, + } + ], + "description": "TestContractBalance.bad5() (tests/incorrect_equality.sol#59-64) uses a dangerous strict equality:\n\t- 10000000000000000000 == balance (tests/incorrect_equality.sol#61)\n", + "markdown": "[TestContractBalance.bad5()](tests/incorrect_equality.sol#L59-L64) uses a dangerous strict equality:\n\t- [10000000000000000000 == balance](tests/incorrect_equality.sol#L61)\n", + "check": "incorrect-equality", + "impact": "Medium", + "confidence": "High" + }, + { + "elements": [ { "type": "function", - "name": "bad5", + "name": "bad6", "source_mapping": { - "start": 1362, - "length": 170, + "start": 1538, + "length": 179, "filename_used": "/home/travis/build/crytic/slither/tests/incorrect_equality.sol", "filename_relative": "tests/incorrect_equality.sol", "filename_absolute": "/home/travis/build/crytic/slither/tests/incorrect_equality.sol", "filename_short": "tests/incorrect_equality.sol", "is_dependency": false, "lines": [ - 59, - 60, - 61, - 62, - 63, - 64 + 66, + 67, + 68, + 69, + 70, + 71 ], "starting_column": 5, "ending_column": 6 @@ -1774,17 +1897,9 @@ "ending_column": 2 } }, - "signature": "bad5()" + "signature": "bad6()" } - } - ] - }, - { - "check": "incorrect-equality", - "impact": "Medium", - "confidence": "High", - "description": "TestContractBalance.bad6() (tests/incorrect_equality.sol#66-71) uses a dangerous strict equality:\n\t- balance == 10000000000000000000\n", - "elements": [ + }, { "type": "node", "name": "balance == 10000000000000000000", @@ -1915,25 +2030,31 @@ } } } - }, + } + ], + "description": "TestContractBalance.bad6() (tests/incorrect_equality.sol#66-71) uses a dangerous strict equality:\n\t- balance == 10000000000000000000 (tests/incorrect_equality.sol#68)\n", + "markdown": "[TestContractBalance.bad6()](tests/incorrect_equality.sol#L66-L71) uses a dangerous strict equality:\n\t- [balance == 10000000000000000000](tests/incorrect_equality.sol#L68)\n", + "check": "incorrect-equality", + "impact": "Medium", + "confidence": "High" + }, + { + "elements": [ { "type": "function", - "name": "bad6", + "name": "bad0", "source_mapping": { - "start": 1538, - "length": 179, + "start": 2935, + "length": 59, "filename_used": "/home/travis/build/crytic/slither/tests/incorrect_equality.sol", "filename_relative": "tests/incorrect_equality.sol", "filename_absolute": "/home/travis/build/crytic/slither/tests/incorrect_equality.sol", "filename_short": "tests/incorrect_equality.sol", "is_dependency": false, "lines": [ - 66, - 67, - 68, - 69, - 70, - 71 + 123, + 124, + 125 ], "starting_column": 5, "ending_column": 6 @@ -1941,100 +2062,61 @@ "type_specific_fields": { "parent": { "type": "contract", - "name": "TestContractBalance", + "name": "TestSolidityKeyword", "source_mapping": { - "start": 612, - "length": 1754, + "start": 2368, + "length": 774, "filename_used": "/home/travis/build/crytic/slither/tests/incorrect_equality.sol", "filename_relative": "tests/incorrect_equality.sol", "filename_absolute": "/home/travis/build/crytic/slither/tests/incorrect_equality.sol", "filename_short": "tests/incorrect_equality.sol", "is_dependency": false, "lines": [ - 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 + 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 ], "starting_column": 1, "ending_column": 2 } }, - "signature": "bad6()" + "signature": "bad0()" } - } - ] - }, - { - "check": "incorrect-equality", - "impact": "Medium", - "confidence": "High", - "description": "TestSolidityKeyword.bad0() (tests/incorrect_equality.sol#123-125) uses a dangerous strict equality:\n\t- require(bool)(now == 0)\n", - "elements": [ + }, { "type": "node", "name": "require(bool)(now == 0)", @@ -2131,22 +2213,31 @@ } } } - }, + } + ], + "description": "TestSolidityKeyword.bad0() (tests/incorrect_equality.sol#123-125) uses a dangerous strict equality:\n\t- require(bool)(now == 0) (tests/incorrect_equality.sol#124)\n", + "markdown": "[TestSolidityKeyword.bad0()](tests/incorrect_equality.sol#L123-L125) uses a dangerous strict equality:\n\t- [require(bool)(now == 0)](tests/incorrect_equality.sol#L124)\n", + "check": "incorrect-equality", + "impact": "Medium", + "confidence": "High" + }, + { + "elements": [ { "type": "function", - "name": "bad0", + "name": "bad1", "source_mapping": { - "start": 2935, - "length": 59, + "start": 3000, + "length": 66, "filename_used": "/home/travis/build/crytic/slither/tests/incorrect_equality.sol", "filename_relative": "tests/incorrect_equality.sol", "filename_absolute": "/home/travis/build/crytic/slither/tests/incorrect_equality.sol", "filename_short": "tests/incorrect_equality.sol", "is_dependency": false, "lines": [ - 123, - 124, - 125 + 127, + 128, + 129 ], "starting_column": 5, "ending_column": 6 @@ -2206,17 +2297,9 @@ "ending_column": 2 } }, - "signature": "bad0()" + "signature": "bad1()" } - } - ] - }, - { - "check": "incorrect-equality", - "impact": "Medium", - "confidence": "High", - "description": "TestSolidityKeyword.bad1() (tests/incorrect_equality.sol#127-129) uses a dangerous strict equality:\n\t- require(bool)(block.number == 0)\n", - "elements": [ + }, { "type": "node", "name": "require(bool)(block.number == 0)", @@ -2313,22 +2396,31 @@ } } } - }, + } + ], + "description": "TestSolidityKeyword.bad1() (tests/incorrect_equality.sol#127-129) uses a dangerous strict equality:\n\t- require(bool)(block.number == 0) (tests/incorrect_equality.sol#128)\n", + "markdown": "[TestSolidityKeyword.bad1()](tests/incorrect_equality.sol#L127-L129) uses a dangerous strict equality:\n\t- [require(bool)(block.number == 0)](tests/incorrect_equality.sol#L128)\n", + "check": "incorrect-equality", + "impact": "Medium", + "confidence": "High" + }, + { + "elements": [ { "type": "function", - "name": "bad1", + "name": "bad2", "source_mapping": { - "start": 3000, - "length": 66, + "start": 3072, + "length": 67, "filename_used": "/home/travis/build/crytic/slither/tests/incorrect_equality.sol", "filename_relative": "tests/incorrect_equality.sol", "filename_absolute": "/home/travis/build/crytic/slither/tests/incorrect_equality.sol", "filename_short": "tests/incorrect_equality.sol", "is_dependency": false, "lines": [ - 127, - 128, - 129 + 131, + 132, + 133 ], "starting_column": 5, "ending_column": 6 @@ -2388,17 +2480,9 @@ "ending_column": 2 } }, - "signature": "bad1()" + "signature": "bad2()" } - } - ] - }, - { - "check": "incorrect-equality", - "impact": "Medium", - "confidence": "High", - "description": "TestSolidityKeyword.bad2() (tests/incorrect_equality.sol#131-133) uses a dangerous strict equality:\n\t- require(bool)(block.number == 0)\n", - "elements": [ + }, { "type": "node", "name": "require(bool)(block.number == 0)", @@ -2495,85 +2579,13 @@ } } } - }, - { - "type": "function", - "name": "bad2", - "source_mapping": { - "start": 3072, - "length": 67, - "filename_used": "/home/travis/build/crytic/slither/tests/incorrect_equality.sol", - "filename_relative": "tests/incorrect_equality.sol", - "filename_absolute": "/home/travis/build/crytic/slither/tests/incorrect_equality.sol", - "filename_short": "tests/incorrect_equality.sol", - "is_dependency": false, - "lines": [ - 131, - 132, - 133 - ], - "starting_column": 5, - "ending_column": 6 - }, - "type_specific_fields": { - "parent": { - "type": "contract", - "name": "TestSolidityKeyword", - "source_mapping": { - "start": 2368, - "length": 774, - "filename_used": "/home/travis/build/crytic/slither/tests/incorrect_equality.sol", - "filename_relative": "tests/incorrect_equality.sol", - "filename_absolute": "/home/travis/build/crytic/slither/tests/incorrect_equality.sol", - "filename_short": "tests/incorrect_equality.sol", - "is_dependency": false, - "lines": [ - 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 - ], - "starting_column": 1, - "ending_column": 2 - } - }, - "signature": "bad2()" - } } - ] + ], + "description": "TestSolidityKeyword.bad2() (tests/incorrect_equality.sol#131-133) uses a dangerous strict equality:\n\t- require(bool)(block.number == 0) (tests/incorrect_equality.sol#132)\n", + "markdown": "[TestSolidityKeyword.bad2()](tests/incorrect_equality.sol#L131-L133) uses a dangerous strict equality:\n\t- [require(bool)(block.number == 0)](tests/incorrect_equality.sol#L132)\n", + "check": "incorrect-equality", + "impact": "Medium", + "confidence": "High" } ] } diff --git a/tests/expected_json/incorrect_equality.incorrect-equality.txt b/tests/expected_json/incorrect_equality.incorrect-equality.txt index afe5a41c4..fedb9a764 100644 --- a/tests/expected_json/incorrect_equality.incorrect-equality.txt +++ b/tests/expected_json/incorrect_equality.incorrect-equality.txt @@ -1,27 +1,27 @@ -INFO:Detectors: + ERC20TestBalance.bad0(ERC20Function) (tests/incorrect_equality.sol#21-23) uses a dangerous strict equality: - - require(bool)(erc.balanceOf(address(this)) == 10) + - require(bool)(erc.balanceOf(address(this)) == 10) (tests/incorrect_equality.sol#22) ERC20TestBalance.bad1(ERC20Variable) (tests/incorrect_equality.sol#25-27) uses a dangerous strict equality: - - require(bool)(erc.balanceOf(msg.sender) == 10) + - require(bool)(erc.balanceOf(msg.sender) == 10) (tests/incorrect_equality.sol#26) TestContractBalance.bad0() (tests/incorrect_equality.sol#32-35) uses a dangerous strict equality: - - require(bool)(address(address(this)).balance == 10000000000000000000) + - require(bool)(address(address(this)).balance == 10000000000000000000) (tests/incorrect_equality.sol#33) TestContractBalance.bad1() (tests/incorrect_equality.sol#37-40) uses a dangerous strict equality: - - require(bool)(10000000000000000000 == address(address(this)).balance) + - require(bool)(10000000000000000000 == address(address(this)).balance) (tests/incorrect_equality.sol#38) TestContractBalance.bad2() (tests/incorrect_equality.sol#42-45) uses a dangerous strict equality: - - require(bool)(address(this).balance == 10000000000000000000) + - require(bool)(address(this).balance == 10000000000000000000) (tests/incorrect_equality.sol#43) TestContractBalance.bad3() (tests/incorrect_equality.sol#47-50) uses a dangerous strict equality: - - require(bool)(10000000000000000000 == address(this).balance) + - require(bool)(10000000000000000000 == address(this).balance) (tests/incorrect_equality.sol#48) TestContractBalance.bad4() (tests/incorrect_equality.sol#52-57) uses a dangerous strict equality: - - balance == 10000000000000000000 + - balance == 10000000000000000000 (tests/incorrect_equality.sol#54) TestContractBalance.bad5() (tests/incorrect_equality.sol#59-64) uses a dangerous strict equality: - - 10000000000000000000 == balance + - 10000000000000000000 == balance (tests/incorrect_equality.sol#61) TestContractBalance.bad6() (tests/incorrect_equality.sol#66-71) uses a dangerous strict equality: - - balance == 10000000000000000000 + - balance == 10000000000000000000 (tests/incorrect_equality.sol#68) TestSolidityKeyword.bad0() (tests/incorrect_equality.sol#123-125) uses a dangerous strict equality: - - require(bool)(now == 0) + - require(bool)(now == 0) (tests/incorrect_equality.sol#124) TestSolidityKeyword.bad1() (tests/incorrect_equality.sol#127-129) uses a dangerous strict equality: - - require(bool)(block.number == 0) + - require(bool)(block.number == 0) (tests/incorrect_equality.sol#128) TestSolidityKeyword.bad2() (tests/incorrect_equality.sol#131-133) uses a dangerous strict equality: - - require(bool)(block.number == 0) + - require(bool)(block.number == 0) (tests/incorrect_equality.sol#132) Reference: https://github.com/crytic/slither/wiki/Detector-Documentation#dangerous-strict-equalities -INFO:Slither:tests/incorrect_equality.sol analyzed (5 contracts), 12 result(s) found +tests/incorrect_equality.sol analyzed (5 contracts with 1 detectors), 12 result(s) found diff --git a/tests/expected_json/incorrect_erc20_interface.erc20-interface.json b/tests/expected_json/incorrect_erc20_interface.erc20-interface.json index c0b6c6b99..b5a9e0ef8 100644 --- a/tests/expected_json/incorrect_erc20_interface.erc20-interface.json +++ b/tests/expected_json/incorrect_erc20_interface.erc20-interface.json @@ -4,11 +4,32 @@ "results": { "detectors": [ { - "check": "erc20-interface", - "impact": "Medium", - "confidence": "High", - "description": "Token (tests/incorrect_erc20_interface.sol#3-10) has incorrect ERC20 function interface: transfer(address,uint256) (tests/incorrect_erc20_interface.sol#4)\n", "elements": [ + { + "type": "contract", + "name": "Token", + "source_mapping": { + "start": 26, + "length": 355, + "filename_used": "/home/travis/build/crytic/slither/tests/incorrect_erc20_interface.sol", + "filename_relative": "tests/incorrect_erc20_interface.sol", + "filename_absolute": "/home/travis/build/crytic/slither/tests/incorrect_erc20_interface.sol", + "filename_short": "tests/incorrect_erc20_interface.sol", + "is_dependency": false, + "lines": [ + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10 + ], + "starting_column": 1, + "ending_column": 2 + } + }, { "type": "function", "name": "transfer", @@ -55,14 +76,40 @@ "signature": "transfer(address,uint256)" } } - ] - }, - { + ], + "description": "Token (tests/incorrect_erc20_interface.sol#3-10) has incorrect ERC20 function interface:Token.transfer(address,uint256) (tests/incorrect_erc20_interface.sol#4)\n", + "markdown": "[Token](tests/incorrect_erc20_interface.sol#L3-L10) has incorrect ERC20 function interface:[Token.transfer(address,uint256)](tests/incorrect_erc20_interface.sol#L4)\n", "check": "erc20-interface", "impact": "Medium", - "confidence": "High", - "description": "Token (tests/incorrect_erc20_interface.sol#3-10) has incorrect ERC20 function interface: approve(address,uint256) (tests/incorrect_erc20_interface.sol#5)\n", + "confidence": "High" + }, + { "elements": [ + { + "type": "contract", + "name": "Token", + "source_mapping": { + "start": 26, + "length": 355, + "filename_used": "/home/travis/build/crytic/slither/tests/incorrect_erc20_interface.sol", + "filename_relative": "tests/incorrect_erc20_interface.sol", + "filename_absolute": "/home/travis/build/crytic/slither/tests/incorrect_erc20_interface.sol", + "filename_short": "tests/incorrect_erc20_interface.sol", + "is_dependency": false, + "lines": [ + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10 + ], + "starting_column": 1, + "ending_column": 2 + } + }, { "type": "function", "name": "approve", @@ -109,14 +156,40 @@ "signature": "approve(address,uint256)" } } - ] - }, - { + ], + "description": "Token (tests/incorrect_erc20_interface.sol#3-10) has incorrect ERC20 function interface:Token.approve(address,uint256) (tests/incorrect_erc20_interface.sol#5)\n", + "markdown": "[Token](tests/incorrect_erc20_interface.sol#L3-L10) has incorrect ERC20 function interface:[Token.approve(address,uint256)](tests/incorrect_erc20_interface.sol#L5)\n", "check": "erc20-interface", "impact": "Medium", - "confidence": "High", - "description": "Token (tests/incorrect_erc20_interface.sol#3-10) has incorrect ERC20 function interface: transferFrom(address,address,uint256) (tests/incorrect_erc20_interface.sol#6)\n", + "confidence": "High" + }, + { "elements": [ + { + "type": "contract", + "name": "Token", + "source_mapping": { + "start": 26, + "length": 355, + "filename_used": "/home/travis/build/crytic/slither/tests/incorrect_erc20_interface.sol", + "filename_relative": "tests/incorrect_erc20_interface.sol", + "filename_absolute": "/home/travis/build/crytic/slither/tests/incorrect_erc20_interface.sol", + "filename_short": "tests/incorrect_erc20_interface.sol", + "is_dependency": false, + "lines": [ + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10 + ], + "starting_column": 1, + "ending_column": 2 + } + }, { "type": "function", "name": "transferFrom", @@ -163,14 +236,40 @@ "signature": "transferFrom(address,address,uint256)" } } - ] - }, - { + ], + "description": "Token (tests/incorrect_erc20_interface.sol#3-10) has incorrect ERC20 function interface:Token.transferFrom(address,address,uint256) (tests/incorrect_erc20_interface.sol#6)\n", + "markdown": "[Token](tests/incorrect_erc20_interface.sol#L3-L10) has incorrect ERC20 function interface:[Token.transferFrom(address,address,uint256)](tests/incorrect_erc20_interface.sol#L6)\n", "check": "erc20-interface", "impact": "Medium", - "confidence": "High", - "description": "Token (tests/incorrect_erc20_interface.sol#3-10) has incorrect ERC20 function interface: totalSupply() (tests/incorrect_erc20_interface.sol#7)\n", + "confidence": "High" + }, + { "elements": [ + { + "type": "contract", + "name": "Token", + "source_mapping": { + "start": 26, + "length": 355, + "filename_used": "/home/travis/build/crytic/slither/tests/incorrect_erc20_interface.sol", + "filename_relative": "tests/incorrect_erc20_interface.sol", + "filename_absolute": "/home/travis/build/crytic/slither/tests/incorrect_erc20_interface.sol", + "filename_short": "tests/incorrect_erc20_interface.sol", + "is_dependency": false, + "lines": [ + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10 + ], + "starting_column": 1, + "ending_column": 2 + } + }, { "type": "function", "name": "totalSupply", @@ -217,14 +316,40 @@ "signature": "totalSupply()" } } - ] - }, - { + ], + "description": "Token (tests/incorrect_erc20_interface.sol#3-10) has incorrect ERC20 function interface:Token.totalSupply() (tests/incorrect_erc20_interface.sol#7)\n", + "markdown": "[Token](tests/incorrect_erc20_interface.sol#L3-L10) has incorrect ERC20 function interface:[Token.totalSupply()](tests/incorrect_erc20_interface.sol#L7)\n", "check": "erc20-interface", "impact": "Medium", - "confidence": "High", - "description": "Token (tests/incorrect_erc20_interface.sol#3-10) has incorrect ERC20 function interface: balanceOf(address) (tests/incorrect_erc20_interface.sol#8)\n", + "confidence": "High" + }, + { "elements": [ + { + "type": "contract", + "name": "Token", + "source_mapping": { + "start": 26, + "length": 355, + "filename_used": "/home/travis/build/crytic/slither/tests/incorrect_erc20_interface.sol", + "filename_relative": "tests/incorrect_erc20_interface.sol", + "filename_absolute": "/home/travis/build/crytic/slither/tests/incorrect_erc20_interface.sol", + "filename_short": "tests/incorrect_erc20_interface.sol", + "is_dependency": false, + "lines": [ + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10 + ], + "starting_column": 1, + "ending_column": 2 + } + }, { "type": "function", "name": "balanceOf", @@ -271,14 +396,40 @@ "signature": "balanceOf(address)" } } - ] - }, - { + ], + "description": "Token (tests/incorrect_erc20_interface.sol#3-10) has incorrect ERC20 function interface:Token.balanceOf(address) (tests/incorrect_erc20_interface.sol#8)\n", + "markdown": "[Token](tests/incorrect_erc20_interface.sol#L3-L10) has incorrect ERC20 function interface:[Token.balanceOf(address)](tests/incorrect_erc20_interface.sol#L8)\n", "check": "erc20-interface", "impact": "Medium", - "confidence": "High", - "description": "Token (tests/incorrect_erc20_interface.sol#3-10) has incorrect ERC20 function interface: allowance(address,address) (tests/incorrect_erc20_interface.sol#9)\n", + "confidence": "High" + }, + { "elements": [ + { + "type": "contract", + "name": "Token", + "source_mapping": { + "start": 26, + "length": 355, + "filename_used": "/home/travis/build/crytic/slither/tests/incorrect_erc20_interface.sol", + "filename_relative": "tests/incorrect_erc20_interface.sol", + "filename_absolute": "/home/travis/build/crytic/slither/tests/incorrect_erc20_interface.sol", + "filename_short": "tests/incorrect_erc20_interface.sol", + "is_dependency": false, + "lines": [ + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10 + ], + "starting_column": 1, + "ending_column": 2 + } + }, { "type": "function", "name": "allowance", @@ -325,7 +476,12 @@ "signature": "allowance(address,address)" } } - ] + ], + "description": "Token (tests/incorrect_erc20_interface.sol#3-10) has incorrect ERC20 function interface:Token.allowance(address,address) (tests/incorrect_erc20_interface.sol#9)\n", + "markdown": "[Token](tests/incorrect_erc20_interface.sol#L3-L10) has incorrect ERC20 function interface:[Token.allowance(address,address)](tests/incorrect_erc20_interface.sol#L9)\n", + "check": "erc20-interface", + "impact": "Medium", + "confidence": "High" } ] } diff --git a/tests/expected_json/incorrect_erc20_interface.erc20-interface.txt b/tests/expected_json/incorrect_erc20_interface.erc20-interface.txt index 75b71be01..24bcc5276 100644 --- a/tests/expected_json/incorrect_erc20_interface.erc20-interface.txt +++ b/tests/expected_json/incorrect_erc20_interface.erc20-interface.txt @@ -1,9 +1,9 @@ -INFO:Detectors: -Token (tests/incorrect_erc20_interface.sol#3-10) has incorrect ERC20 function interface: transfer(address,uint256) (tests/incorrect_erc20_interface.sol#4) -Token (tests/incorrect_erc20_interface.sol#3-10) has incorrect ERC20 function interface: approve(address,uint256) (tests/incorrect_erc20_interface.sol#5) -Token (tests/incorrect_erc20_interface.sol#3-10) has incorrect ERC20 function interface: transferFrom(address,address,uint256) (tests/incorrect_erc20_interface.sol#6) -Token (tests/incorrect_erc20_interface.sol#3-10) has incorrect ERC20 function interface: totalSupply() (tests/incorrect_erc20_interface.sol#7) -Token (tests/incorrect_erc20_interface.sol#3-10) has incorrect ERC20 function interface: balanceOf(address) (tests/incorrect_erc20_interface.sol#8) -Token (tests/incorrect_erc20_interface.sol#3-10) has incorrect ERC20 function interface: allowance(address,address) (tests/incorrect_erc20_interface.sol#9) + +Token (tests/incorrect_erc20_interface.sol#3-10) has incorrect ERC20 function interface:Token.transfer(address,uint256) (tests/incorrect_erc20_interface.sol#4) +Token (tests/incorrect_erc20_interface.sol#3-10) has incorrect ERC20 function interface:Token.approve(address,uint256) (tests/incorrect_erc20_interface.sol#5) +Token (tests/incorrect_erc20_interface.sol#3-10) has incorrect ERC20 function interface:Token.transferFrom(address,address,uint256) (tests/incorrect_erc20_interface.sol#6) +Token (tests/incorrect_erc20_interface.sol#3-10) has incorrect ERC20 function interface:Token.totalSupply() (tests/incorrect_erc20_interface.sol#7) +Token (tests/incorrect_erc20_interface.sol#3-10) has incorrect ERC20 function interface:Token.balanceOf(address) (tests/incorrect_erc20_interface.sol#8) +Token (tests/incorrect_erc20_interface.sol#3-10) has incorrect ERC20 function interface:Token.allowance(address,address) (tests/incorrect_erc20_interface.sol#9) Reference: https://github.com/crytic/slither/wiki/Detector-Documentation#incorrect-erc20-interface -INFO:Slither:tests/incorrect_erc20_interface.sol analyzed (1 contracts), 6 result(s) found +tests/incorrect_erc20_interface.sol analyzed (1 contracts with 1 detectors), 6 result(s) found diff --git a/tests/expected_json/incorrect_erc721_interface.erc721-interface.json b/tests/expected_json/incorrect_erc721_interface.erc721-interface.json index 528be3fc0..1bc67621f 100644 --- a/tests/expected_json/incorrect_erc721_interface.erc721-interface.json +++ b/tests/expected_json/incorrect_erc721_interface.erc721-interface.json @@ -4,11 +4,35 @@ "results": { "detectors": [ { - "check": "erc721-interface", - "impact": "Medium", - "confidence": "High", - "description": "Token (tests/incorrect_erc721_interface.sol#6-16) has incorrect ERC721 function interface: supportsInterface(bytes4) (tests/incorrect_erc721_interface.sol#4)\n", "elements": [ + { + "type": "contract", + "name": "Token", + "source_mapping": { + "start": 109, + "length": 739, + "filename_used": "/home/travis/build/crytic/slither/tests/incorrect_erc721_interface.sol", + "filename_relative": "tests/incorrect_erc721_interface.sol", + "filename_absolute": "/home/travis/build/crytic/slither/tests/incorrect_erc721_interface.sol", + "filename_short": "tests/incorrect_erc721_interface.sol", + "is_dependency": false, + "lines": [ + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16 + ], + "starting_column": 1, + "ending_column": 2 + } + }, { "type": "function", "name": "supportsInterface", @@ -50,14 +74,43 @@ "signature": "supportsInterface(bytes4)" } } - ] - }, - { + ], + "description": "Token (tests/incorrect_erc721_interface.sol#6-16) has incorrect ERC721 function interface:IERC165.supportsInterface(bytes4) (tests/incorrect_erc721_interface.sol#4)\n", + "markdown": "[Token](tests/incorrect_erc721_interface.sol#L6-L16) has incorrect ERC721 function interface:[IERC165.supportsInterface(bytes4)](tests/incorrect_erc721_interface.sol#L4)\n", "check": "erc721-interface", "impact": "Medium", - "confidence": "High", - "description": "Token (tests/incorrect_erc721_interface.sol#6-16) has incorrect ERC721 function interface: balanceOf(address) (tests/incorrect_erc721_interface.sol#7)\n", + "confidence": "High" + }, + { "elements": [ + { + "type": "contract", + "name": "Token", + "source_mapping": { + "start": 109, + "length": 739, + "filename_used": "/home/travis/build/crytic/slither/tests/incorrect_erc721_interface.sol", + "filename_relative": "tests/incorrect_erc721_interface.sol", + "filename_absolute": "/home/travis/build/crytic/slither/tests/incorrect_erc721_interface.sol", + "filename_short": "tests/incorrect_erc721_interface.sol", + "is_dependency": false, + "lines": [ + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16 + ], + "starting_column": 1, + "ending_column": 2 + } + }, { "type": "function", "name": "balanceOf", @@ -107,14 +160,43 @@ "signature": "balanceOf(address)" } } - ] - }, - { + ], + "description": "Token (tests/incorrect_erc721_interface.sol#6-16) has incorrect ERC721 function interface:Token.balanceOf(address) (tests/incorrect_erc721_interface.sol#7)\n", + "markdown": "[Token](tests/incorrect_erc721_interface.sol#L6-L16) has incorrect ERC721 function interface:[Token.balanceOf(address)](tests/incorrect_erc721_interface.sol#L7)\n", "check": "erc721-interface", "impact": "Medium", - "confidence": "High", - "description": "Token (tests/incorrect_erc721_interface.sol#6-16) has incorrect ERC721 function interface: ownerOf(uint256) (tests/incorrect_erc721_interface.sol#8)\n", + "confidence": "High" + }, + { "elements": [ + { + "type": "contract", + "name": "Token", + "source_mapping": { + "start": 109, + "length": 739, + "filename_used": "/home/travis/build/crytic/slither/tests/incorrect_erc721_interface.sol", + "filename_relative": "tests/incorrect_erc721_interface.sol", + "filename_absolute": "/home/travis/build/crytic/slither/tests/incorrect_erc721_interface.sol", + "filename_short": "tests/incorrect_erc721_interface.sol", + "is_dependency": false, + "lines": [ + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16 + ], + "starting_column": 1, + "ending_column": 2 + } + }, { "type": "function", "name": "ownerOf", @@ -164,14 +246,43 @@ "signature": "ownerOf(uint256)" } } - ] - }, - { + ], + "description": "Token (tests/incorrect_erc721_interface.sol#6-16) has incorrect ERC721 function interface:Token.ownerOf(uint256) (tests/incorrect_erc721_interface.sol#8)\n", + "markdown": "[Token](tests/incorrect_erc721_interface.sol#L6-L16) has incorrect ERC721 function interface:[Token.ownerOf(uint256)](tests/incorrect_erc721_interface.sol#L8)\n", "check": "erc721-interface", "impact": "Medium", - "confidence": "High", - "description": "Token (tests/incorrect_erc721_interface.sol#6-16) has incorrect ERC721 function interface: safeTransferFrom(address,address,uint256,bytes) (tests/incorrect_erc721_interface.sol#9)\n", + "confidence": "High" + }, + { "elements": [ + { + "type": "contract", + "name": "Token", + "source_mapping": { + "start": 109, + "length": 739, + "filename_used": "/home/travis/build/crytic/slither/tests/incorrect_erc721_interface.sol", + "filename_relative": "tests/incorrect_erc721_interface.sol", + "filename_absolute": "/home/travis/build/crytic/slither/tests/incorrect_erc721_interface.sol", + "filename_short": "tests/incorrect_erc721_interface.sol", + "is_dependency": false, + "lines": [ + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16 + ], + "starting_column": 1, + "ending_column": 2 + } + }, { "type": "function", "name": "safeTransferFrom", @@ -221,14 +332,43 @@ "signature": "safeTransferFrom(address,address,uint256,bytes)" } } - ] - }, - { + ], + "description": "Token (tests/incorrect_erc721_interface.sol#6-16) has incorrect ERC721 function interface:Token.safeTransferFrom(address,address,uint256,bytes) (tests/incorrect_erc721_interface.sol#9)\n", + "markdown": "[Token](tests/incorrect_erc721_interface.sol#L6-L16) has incorrect ERC721 function interface:[Token.safeTransferFrom(address,address,uint256,bytes)](tests/incorrect_erc721_interface.sol#L9)\n", "check": "erc721-interface", "impact": "Medium", - "confidence": "High", - "description": "Token (tests/incorrect_erc721_interface.sol#6-16) has incorrect ERC721 function interface: safeTransferFrom(address,address,uint256) (tests/incorrect_erc721_interface.sol#10)\n", + "confidence": "High" + }, + { "elements": [ + { + "type": "contract", + "name": "Token", + "source_mapping": { + "start": 109, + "length": 739, + "filename_used": "/home/travis/build/crytic/slither/tests/incorrect_erc721_interface.sol", + "filename_relative": "tests/incorrect_erc721_interface.sol", + "filename_absolute": "/home/travis/build/crytic/slither/tests/incorrect_erc721_interface.sol", + "filename_short": "tests/incorrect_erc721_interface.sol", + "is_dependency": false, + "lines": [ + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16 + ], + "starting_column": 1, + "ending_column": 2 + } + }, { "type": "function", "name": "safeTransferFrom", @@ -278,14 +418,43 @@ "signature": "safeTransferFrom(address,address,uint256)" } } - ] - }, - { + ], + "description": "Token (tests/incorrect_erc721_interface.sol#6-16) has incorrect ERC721 function interface:Token.safeTransferFrom(address,address,uint256) (tests/incorrect_erc721_interface.sol#10)\n", + "markdown": "[Token](tests/incorrect_erc721_interface.sol#L6-L16) has incorrect ERC721 function interface:[Token.safeTransferFrom(address,address,uint256)](tests/incorrect_erc721_interface.sol#L10)\n", "check": "erc721-interface", "impact": "Medium", - "confidence": "High", - "description": "Token (tests/incorrect_erc721_interface.sol#6-16) has incorrect ERC721 function interface: transferFrom(address,address,uint256) (tests/incorrect_erc721_interface.sol#11)\n", + "confidence": "High" + }, + { "elements": [ + { + "type": "contract", + "name": "Token", + "source_mapping": { + "start": 109, + "length": 739, + "filename_used": "/home/travis/build/crytic/slither/tests/incorrect_erc721_interface.sol", + "filename_relative": "tests/incorrect_erc721_interface.sol", + "filename_absolute": "/home/travis/build/crytic/slither/tests/incorrect_erc721_interface.sol", + "filename_short": "tests/incorrect_erc721_interface.sol", + "is_dependency": false, + "lines": [ + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16 + ], + "starting_column": 1, + "ending_column": 2 + } + }, { "type": "function", "name": "transferFrom", @@ -335,14 +504,43 @@ "signature": "transferFrom(address,address,uint256)" } } - ] - }, - { + ], + "description": "Token (tests/incorrect_erc721_interface.sol#6-16) has incorrect ERC721 function interface:Token.transferFrom(address,address,uint256) (tests/incorrect_erc721_interface.sol#11)\n", + "markdown": "[Token](tests/incorrect_erc721_interface.sol#L6-L16) has incorrect ERC721 function interface:[Token.transferFrom(address,address,uint256)](tests/incorrect_erc721_interface.sol#L11)\n", "check": "erc721-interface", "impact": "Medium", - "confidence": "High", - "description": "Token (tests/incorrect_erc721_interface.sol#6-16) has incorrect ERC721 function interface: approve(address,uint256) (tests/incorrect_erc721_interface.sol#12)\n", + "confidence": "High" + }, + { "elements": [ + { + "type": "contract", + "name": "Token", + "source_mapping": { + "start": 109, + "length": 739, + "filename_used": "/home/travis/build/crytic/slither/tests/incorrect_erc721_interface.sol", + "filename_relative": "tests/incorrect_erc721_interface.sol", + "filename_absolute": "/home/travis/build/crytic/slither/tests/incorrect_erc721_interface.sol", + "filename_short": "tests/incorrect_erc721_interface.sol", + "is_dependency": false, + "lines": [ + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16 + ], + "starting_column": 1, + "ending_column": 2 + } + }, { "type": "function", "name": "approve", @@ -392,14 +590,43 @@ "signature": "approve(address,uint256)" } } - ] - }, - { + ], + "description": "Token (tests/incorrect_erc721_interface.sol#6-16) has incorrect ERC721 function interface:Token.approve(address,uint256) (tests/incorrect_erc721_interface.sol#12)\n", + "markdown": "[Token](tests/incorrect_erc721_interface.sol#L6-L16) has incorrect ERC721 function interface:[Token.approve(address,uint256)](tests/incorrect_erc721_interface.sol#L12)\n", "check": "erc721-interface", "impact": "Medium", - "confidence": "High", - "description": "Token (tests/incorrect_erc721_interface.sol#6-16) has incorrect ERC721 function interface: setApprovalForAll(address,bool) (tests/incorrect_erc721_interface.sol#13)\n", + "confidence": "High" + }, + { "elements": [ + { + "type": "contract", + "name": "Token", + "source_mapping": { + "start": 109, + "length": 739, + "filename_used": "/home/travis/build/crytic/slither/tests/incorrect_erc721_interface.sol", + "filename_relative": "tests/incorrect_erc721_interface.sol", + "filename_absolute": "/home/travis/build/crytic/slither/tests/incorrect_erc721_interface.sol", + "filename_short": "tests/incorrect_erc721_interface.sol", + "is_dependency": false, + "lines": [ + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16 + ], + "starting_column": 1, + "ending_column": 2 + } + }, { "type": "function", "name": "setApprovalForAll", @@ -449,14 +676,43 @@ "signature": "setApprovalForAll(address,bool)" } } - ] - }, - { + ], + "description": "Token (tests/incorrect_erc721_interface.sol#6-16) has incorrect ERC721 function interface:Token.setApprovalForAll(address,bool) (tests/incorrect_erc721_interface.sol#13)\n", + "markdown": "[Token](tests/incorrect_erc721_interface.sol#L6-L16) has incorrect ERC721 function interface:[Token.setApprovalForAll(address,bool)](tests/incorrect_erc721_interface.sol#L13)\n", "check": "erc721-interface", "impact": "Medium", - "confidence": "High", - "description": "Token (tests/incorrect_erc721_interface.sol#6-16) has incorrect ERC721 function interface: getApproved(uint256) (tests/incorrect_erc721_interface.sol#14)\n", + "confidence": "High" + }, + { "elements": [ + { + "type": "contract", + "name": "Token", + "source_mapping": { + "start": 109, + "length": 739, + "filename_used": "/home/travis/build/crytic/slither/tests/incorrect_erc721_interface.sol", + "filename_relative": "tests/incorrect_erc721_interface.sol", + "filename_absolute": "/home/travis/build/crytic/slither/tests/incorrect_erc721_interface.sol", + "filename_short": "tests/incorrect_erc721_interface.sol", + "is_dependency": false, + "lines": [ + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16 + ], + "starting_column": 1, + "ending_column": 2 + } + }, { "type": "function", "name": "getApproved", @@ -506,14 +762,43 @@ "signature": "getApproved(uint256)" } } - ] - }, - { + ], + "description": "Token (tests/incorrect_erc721_interface.sol#6-16) has incorrect ERC721 function interface:Token.getApproved(uint256) (tests/incorrect_erc721_interface.sol#14)\n", + "markdown": "[Token](tests/incorrect_erc721_interface.sol#L6-L16) has incorrect ERC721 function interface:[Token.getApproved(uint256)](tests/incorrect_erc721_interface.sol#L14)\n", "check": "erc721-interface", "impact": "Medium", - "confidence": "High", - "description": "Token (tests/incorrect_erc721_interface.sol#6-16) has incorrect ERC721 function interface: isApprovedForAll(address,address) (tests/incorrect_erc721_interface.sol#15)\n", + "confidence": "High" + }, + { "elements": [ + { + "type": "contract", + "name": "Token", + "source_mapping": { + "start": 109, + "length": 739, + "filename_used": "/home/travis/build/crytic/slither/tests/incorrect_erc721_interface.sol", + "filename_relative": "tests/incorrect_erc721_interface.sol", + "filename_absolute": "/home/travis/build/crytic/slither/tests/incorrect_erc721_interface.sol", + "filename_short": "tests/incorrect_erc721_interface.sol", + "is_dependency": false, + "lines": [ + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16 + ], + "starting_column": 1, + "ending_column": 2 + } + }, { "type": "function", "name": "isApprovedForAll", @@ -563,7 +848,12 @@ "signature": "isApprovedForAll(address,address)" } } - ] + ], + "description": "Token (tests/incorrect_erc721_interface.sol#6-16) has incorrect ERC721 function interface:Token.isApprovedForAll(address,address) (tests/incorrect_erc721_interface.sol#15)\n", + "markdown": "[Token](tests/incorrect_erc721_interface.sol#L6-L16) has incorrect ERC721 function interface:[Token.isApprovedForAll(address,address)](tests/incorrect_erc721_interface.sol#L15)\n", + "check": "erc721-interface", + "impact": "Medium", + "confidence": "High" } ] } diff --git a/tests/expected_json/incorrect_erc721_interface.erc721-interface.txt b/tests/expected_json/incorrect_erc721_interface.erc721-interface.txt index cfd388267..4a82240e2 100644 --- a/tests/expected_json/incorrect_erc721_interface.erc721-interface.txt +++ b/tests/expected_json/incorrect_erc721_interface.erc721-interface.txt @@ -1,13 +1,13 @@ -INFO:Detectors: -Token (tests/incorrect_erc721_interface.sol#6-16) has incorrect ERC721 function interface: supportsInterface(bytes4) (tests/incorrect_erc721_interface.sol#4) -Token (tests/incorrect_erc721_interface.sol#6-16) has incorrect ERC721 function interface: balanceOf(address) (tests/incorrect_erc721_interface.sol#7) -Token (tests/incorrect_erc721_interface.sol#6-16) has incorrect ERC721 function interface: ownerOf(uint256) (tests/incorrect_erc721_interface.sol#8) -Token (tests/incorrect_erc721_interface.sol#6-16) has incorrect ERC721 function interface: safeTransferFrom(address,address,uint256,bytes) (tests/incorrect_erc721_interface.sol#9) -Token (tests/incorrect_erc721_interface.sol#6-16) has incorrect ERC721 function interface: safeTransferFrom(address,address,uint256) (tests/incorrect_erc721_interface.sol#10) -Token (tests/incorrect_erc721_interface.sol#6-16) has incorrect ERC721 function interface: transferFrom(address,address,uint256) (tests/incorrect_erc721_interface.sol#11) -Token (tests/incorrect_erc721_interface.sol#6-16) has incorrect ERC721 function interface: approve(address,uint256) (tests/incorrect_erc721_interface.sol#12) -Token (tests/incorrect_erc721_interface.sol#6-16) has incorrect ERC721 function interface: setApprovalForAll(address,bool) (tests/incorrect_erc721_interface.sol#13) -Token (tests/incorrect_erc721_interface.sol#6-16) has incorrect ERC721 function interface: getApproved(uint256) (tests/incorrect_erc721_interface.sol#14) -Token (tests/incorrect_erc721_interface.sol#6-16) has incorrect ERC721 function interface: isApprovedForAll(address,address) (tests/incorrect_erc721_interface.sol#15) + +Token (tests/incorrect_erc721_interface.sol#6-16) has incorrect ERC721 function interface:IERC165.supportsInterface(bytes4) (tests/incorrect_erc721_interface.sol#4) +Token (tests/incorrect_erc721_interface.sol#6-16) has incorrect ERC721 function interface:Token.balanceOf(address) (tests/incorrect_erc721_interface.sol#7) +Token (tests/incorrect_erc721_interface.sol#6-16) has incorrect ERC721 function interface:Token.ownerOf(uint256) (tests/incorrect_erc721_interface.sol#8) +Token (tests/incorrect_erc721_interface.sol#6-16) has incorrect ERC721 function interface:Token.safeTransferFrom(address,address,uint256,bytes) (tests/incorrect_erc721_interface.sol#9) +Token (tests/incorrect_erc721_interface.sol#6-16) has incorrect ERC721 function interface:Token.safeTransferFrom(address,address,uint256) (tests/incorrect_erc721_interface.sol#10) +Token (tests/incorrect_erc721_interface.sol#6-16) has incorrect ERC721 function interface:Token.transferFrom(address,address,uint256) (tests/incorrect_erc721_interface.sol#11) +Token (tests/incorrect_erc721_interface.sol#6-16) has incorrect ERC721 function interface:Token.approve(address,uint256) (tests/incorrect_erc721_interface.sol#12) +Token (tests/incorrect_erc721_interface.sol#6-16) has incorrect ERC721 function interface:Token.setApprovalForAll(address,bool) (tests/incorrect_erc721_interface.sol#13) +Token (tests/incorrect_erc721_interface.sol#6-16) has incorrect ERC721 function interface:Token.getApproved(uint256) (tests/incorrect_erc721_interface.sol#14) +Token (tests/incorrect_erc721_interface.sol#6-16) has incorrect ERC721 function interface:Token.isApprovedForAll(address,address) (tests/incorrect_erc721_interface.sol#15) Reference: https://github.com/crytic/slither/wiki/Detector-Documentation#incorrect-erc721-interface -INFO:Slither:tests/incorrect_erc721_interface.sol analyzed (2 contracts), 10 result(s) found +tests/incorrect_erc721_interface.sol analyzed (2 contracts with 1 detectors), 10 result(s) found diff --git a/tests/expected_json/inline_assembly_contract-0.5.1.assembly.json b/tests/expected_json/inline_assembly_contract-0.5.1.assembly.json index 24790e712..8ec3e0312 100644 --- a/tests/expected_json/inline_assembly_contract-0.5.1.assembly.json +++ b/tests/expected_json/inline_assembly_contract-0.5.1.assembly.json @@ -4,10 +4,6 @@ "results": { "detectors": [ { - "check": "assembly", - "impact": "Informational", - "confidence": "High", - "description": "GetCode.at(address) uses assembly (tests/inline_assembly_contract-0.5.1.sol#6-20)\n\t- tests/inline_assembly_contract-0.5.1.sol#7-20\n", "elements": [ { "type": "function", @@ -180,7 +176,12 @@ } } } - ] + ], + "description": "GetCode.at(address) (tests/inline_assembly_contract-0.5.1.sol#6-20) uses assembly\n\t- INLINE ASM None (tests/inline_assembly_contract-0.5.1.sol#7-20)\n", + "markdown": "[GetCode.at(address)](tests/inline_assembly_contract-0.5.1.sol#L6-L20) uses assembly\n\t- [INLINE ASM None](tests/inline_assembly_contract-0.5.1.sol#L7-L20)\n", + "check": "assembly", + "impact": "Informational", + "confidence": "High" } ] } diff --git a/tests/expected_json/inline_assembly_contract-0.5.1.assembly.txt b/tests/expected_json/inline_assembly_contract-0.5.1.assembly.txt index f832cfe46..3fe0a4672 100644 --- a/tests/expected_json/inline_assembly_contract-0.5.1.assembly.txt +++ b/tests/expected_json/inline_assembly_contract-0.5.1.assembly.txt @@ -1,5 +1,5 @@ -INFO:Detectors: -GetCode.at(address) uses assembly (tests/inline_assembly_contract-0.5.1.sol#6-20) - - tests/inline_assembly_contract-0.5.1.sol#7-20 + +GetCode.at(address) (tests/inline_assembly_contract-0.5.1.sol#6-20) uses assembly + - INLINE ASM None (tests/inline_assembly_contract-0.5.1.sol#7-20) Reference: https://github.com/crytic/slither/wiki/Detector-Documentation#assembly-usage -INFO:Slither:tests/inline_assembly_contract-0.5.1.sol analyzed (1 contracts), 1 result(s) found +tests/inline_assembly_contract-0.5.1.sol analyzed (1 contracts with 1 detectors), 1 result(s) found diff --git a/tests/expected_json/inline_assembly_contract.assembly.json b/tests/expected_json/inline_assembly_contract.assembly.json index 75e439a7e..841fb9aa3 100644 --- a/tests/expected_json/inline_assembly_contract.assembly.json +++ b/tests/expected_json/inline_assembly_contract.assembly.json @@ -4,10 +4,6 @@ "results": { "detectors": [ { - "check": "assembly", - "impact": "Informational", - "confidence": "High", - "description": "GetCode.at(address) uses assembly (tests/inline_assembly_contract.sol#6-20)\n\t- tests/inline_assembly_contract.sol#7-20\n", "elements": [ { "type": "function", @@ -180,7 +176,12 @@ } } } - ] + ], + "description": "GetCode.at(address) (tests/inline_assembly_contract.sol#6-20) uses assembly\n\t- INLINE ASM None (tests/inline_assembly_contract.sol#7-20)\n", + "markdown": "[GetCode.at(address)](tests/inline_assembly_contract.sol#L6-L20) uses assembly\n\t- [INLINE ASM None](tests/inline_assembly_contract.sol#L7-L20)\n", + "check": "assembly", + "impact": "Informational", + "confidence": "High" } ] } diff --git a/tests/expected_json/inline_assembly_contract.assembly.txt b/tests/expected_json/inline_assembly_contract.assembly.txt index 78c4fa50c..63450506c 100644 --- a/tests/expected_json/inline_assembly_contract.assembly.txt +++ b/tests/expected_json/inline_assembly_contract.assembly.txt @@ -1,5 +1,5 @@ -INFO:Detectors: -GetCode.at(address) uses assembly (tests/inline_assembly_contract.sol#6-20) - - tests/inline_assembly_contract.sol#7-20 + +GetCode.at(address) (tests/inline_assembly_contract.sol#6-20) uses assembly + - INLINE ASM None (tests/inline_assembly_contract.sol#7-20) Reference: https://github.com/crytic/slither/wiki/Detector-Documentation#assembly-usage -INFO:Slither:tests/inline_assembly_contract.sol analyzed (1 contracts), 1 result(s) found +tests/inline_assembly_contract.sol analyzed (1 contracts with 1 detectors), 1 result(s) found diff --git a/tests/expected_json/inline_assembly_library-0.5.1.assembly.json b/tests/expected_json/inline_assembly_library-0.5.1.assembly.json index bd9b4d97f..f027b15b9 100644 --- a/tests/expected_json/inline_assembly_library-0.5.1.assembly.json +++ b/tests/expected_json/inline_assembly_library-0.5.1.assembly.json @@ -4,10 +4,6 @@ "results": { "detectors": [ { - "check": "assembly", - "impact": "Informational", - "confidence": "High", - "description": "VectorSum.sumAsm(uint256[]) uses assembly (tests/inline_assembly_library-0.5.1.sol#16-22)\n\t- tests/inline_assembly_library-0.5.1.sol#18-21\n", "elements": [ { "type": "function", @@ -208,13 +204,14 @@ } } } - ] - }, - { + ], + "description": "VectorSum.sumAsm(uint256[]) (tests/inline_assembly_library-0.5.1.sol#16-22) uses assembly\n\t- INLINE ASM None (tests/inline_assembly_library-0.5.1.sol#18-21)\n", + "markdown": "[VectorSum.sumAsm(uint256[])](tests/inline_assembly_library-0.5.1.sol#L16-L22) uses assembly\n\t- [INLINE ASM None](tests/inline_assembly_library-0.5.1.sol#L18-L21)\n", "check": "assembly", "impact": "Informational", - "confidence": "High", - "description": "VectorSum.sumPureAsm(uint256[]) uses assembly (tests/inline_assembly_library-0.5.1.sol#25-47)\n\t- tests/inline_assembly_library-0.5.1.sol#26-47\n", + "confidence": "High" + }, + { "elements": [ { "type": "function", @@ -465,7 +462,12 @@ } } } - ] + ], + "description": "VectorSum.sumPureAsm(uint256[]) (tests/inline_assembly_library-0.5.1.sol#25-47) uses assembly\n\t- INLINE ASM None (tests/inline_assembly_library-0.5.1.sol#26-47)\n", + "markdown": "[VectorSum.sumPureAsm(uint256[])](tests/inline_assembly_library-0.5.1.sol#L25-L47) uses assembly\n\t- [INLINE ASM None](tests/inline_assembly_library-0.5.1.sol#L26-L47)\n", + "check": "assembly", + "impact": "Informational", + "confidence": "High" } ] } diff --git a/tests/expected_json/inline_assembly_library-0.5.1.assembly.txt b/tests/expected_json/inline_assembly_library-0.5.1.assembly.txt index 5624ad2cf..ce08b243b 100644 --- a/tests/expected_json/inline_assembly_library-0.5.1.assembly.txt +++ b/tests/expected_json/inline_assembly_library-0.5.1.assembly.txt @@ -1,7 +1,7 @@ -INFO:Detectors: -VectorSum.sumAsm(uint256[]) uses assembly (tests/inline_assembly_library-0.5.1.sol#16-22) - - tests/inline_assembly_library-0.5.1.sol#18-21 -VectorSum.sumPureAsm(uint256[]) uses assembly (tests/inline_assembly_library-0.5.1.sol#25-47) - - tests/inline_assembly_library-0.5.1.sol#26-47 + +VectorSum.sumAsm(uint256[]) (tests/inline_assembly_library-0.5.1.sol#16-22) uses assembly + - INLINE ASM None (tests/inline_assembly_library-0.5.1.sol#18-21) +VectorSum.sumPureAsm(uint256[]) (tests/inline_assembly_library-0.5.1.sol#25-47) uses assembly + - INLINE ASM None (tests/inline_assembly_library-0.5.1.sol#26-47) Reference: https://github.com/crytic/slither/wiki/Detector-Documentation#assembly-usage -INFO:Slither:tests/inline_assembly_library-0.5.1.sol analyzed (1 contracts), 2 result(s) found +tests/inline_assembly_library-0.5.1.sol analyzed (1 contracts with 1 detectors), 2 result(s) found diff --git a/tests/expected_json/inline_assembly_library.assembly.json b/tests/expected_json/inline_assembly_library.assembly.json index 5c1230028..d3e3642b8 100644 --- a/tests/expected_json/inline_assembly_library.assembly.json +++ b/tests/expected_json/inline_assembly_library.assembly.json @@ -4,10 +4,6 @@ "results": { "detectors": [ { - "check": "assembly", - "impact": "Informational", - "confidence": "High", - "description": "VectorSum.sumAsm(uint256[]) uses assembly (tests/inline_assembly_library.sol#16-22)\n\t- tests/inline_assembly_library.sol#18-21\n", "elements": [ { "type": "function", @@ -208,13 +204,14 @@ } } } - ] - }, - { + ], + "description": "VectorSum.sumAsm(uint256[]) (tests/inline_assembly_library.sol#16-22) uses assembly\n\t- INLINE ASM None (tests/inline_assembly_library.sol#18-21)\n", + "markdown": "[VectorSum.sumAsm(uint256[])](tests/inline_assembly_library.sol#L16-L22) uses assembly\n\t- [INLINE ASM None](tests/inline_assembly_library.sol#L18-L21)\n", "check": "assembly", "impact": "Informational", - "confidence": "High", - "description": "VectorSum.sumPureAsm(uint256[]) uses assembly (tests/inline_assembly_library.sol#25-47)\n\t- tests/inline_assembly_library.sol#26-47\n", + "confidence": "High" + }, + { "elements": [ { "type": "function", @@ -465,7 +462,12 @@ } } } - ] + ], + "description": "VectorSum.sumPureAsm(uint256[]) (tests/inline_assembly_library.sol#25-47) uses assembly\n\t- INLINE ASM None (tests/inline_assembly_library.sol#26-47)\n", + "markdown": "[VectorSum.sumPureAsm(uint256[])](tests/inline_assembly_library.sol#L25-L47) uses assembly\n\t- [INLINE ASM None](tests/inline_assembly_library.sol#L26-L47)\n", + "check": "assembly", + "impact": "Informational", + "confidence": "High" } ] } diff --git a/tests/expected_json/inline_assembly_library.assembly.txt b/tests/expected_json/inline_assembly_library.assembly.txt index 8bc566c04..2700f394b 100644 --- a/tests/expected_json/inline_assembly_library.assembly.txt +++ b/tests/expected_json/inline_assembly_library.assembly.txt @@ -1,7 +1,7 @@ -INFO:Detectors: -VectorSum.sumAsm(uint256[]) uses assembly (tests/inline_assembly_library.sol#16-22) - - tests/inline_assembly_library.sol#18-21 -VectorSum.sumPureAsm(uint256[]) uses assembly (tests/inline_assembly_library.sol#25-47) - - tests/inline_assembly_library.sol#26-47 + +VectorSum.sumAsm(uint256[]) (tests/inline_assembly_library.sol#16-22) uses assembly + - INLINE ASM None (tests/inline_assembly_library.sol#18-21) +VectorSum.sumPureAsm(uint256[]) (tests/inline_assembly_library.sol#25-47) uses assembly + - INLINE ASM None (tests/inline_assembly_library.sol#26-47) Reference: https://github.com/crytic/slither/wiki/Detector-Documentation#assembly-usage -INFO:Slither:tests/inline_assembly_library.sol analyzed (1 contracts), 2 result(s) found +tests/inline_assembly_library.sol analyzed (1 contracts with 1 detectors), 2 result(s) found diff --git a/tests/expected_json/locked_ether-0.5.1.locked-ether.json b/tests/expected_json/locked_ether-0.5.1.locked-ether.json index d848114fd..3d7238e5b 100644 --- a/tests/expected_json/locked_ether-0.5.1.locked-ether.json +++ b/tests/expected_json/locked_ether-0.5.1.locked-ether.json @@ -4,10 +4,6 @@ "results": { "detectors": [ { - "check": "locked-ether", - "impact": "Medium", - "confidence": "High", - "description": "Contract locking ether found in :\n\tContract OnlyLocked has payable functions:\n\t - receive (tests/locked_ether-0.5.1.sol#4-6)\n\tBut does not have a function to withdraw the ether\n", "elements": [ { "type": "contract", @@ -74,7 +70,12 @@ "signature": "receive()" } } - ] + ], + "description": "Contract locking ether found in :\n\tContract OnlyLocked (tests/locked_ether-0.5.1.sol#26) has payable functions:\n\t - Locked.receive() (tests/locked_ether-0.5.1.sol#4-6)\n\tBut does not have a function to withdraw the ether\n", + "markdown": "Contract locking ether found in :\n\tContract [OnlyLocked](tests/locked_ether-0.5.1.sol#L26) has payable functions:\n\t - [Locked.receive()](tests/locked_ether-0.5.1.sol#L4-L6)\n\tBut does not have a function to withdraw the ether\n", + "check": "locked-ether", + "impact": "Medium", + "confidence": "High" } ] } diff --git a/tests/expected_json/locked_ether-0.5.1.locked-ether.txt b/tests/expected_json/locked_ether-0.5.1.locked-ether.txt index 1d0fa6d3b..932326656 100644 --- a/tests/expected_json/locked_ether-0.5.1.locked-ether.txt +++ b/tests/expected_json/locked_ether-0.5.1.locked-ether.txt @@ -1,7 +1,7 @@ -INFO:Detectors: + Contract locking ether found in : - Contract OnlyLocked has payable functions: - - receive (tests/locked_ether-0.5.1.sol#4-6) + Contract OnlyLocked (tests/locked_ether-0.5.1.sol#26) has payable functions: + - Locked.receive() (tests/locked_ether-0.5.1.sol#4-6) But does not have a function to withdraw the ether Reference: https://github.com/crytic/slither/wiki/Detector-Documentation#contracts-that-lock-ether -INFO:Slither:tests/locked_ether-0.5.1.sol analyzed (4 contracts), 1 result(s) found +tests/locked_ether-0.5.1.sol analyzed (4 contracts with 1 detectors), 1 result(s) found diff --git a/tests/expected_json/locked_ether.locked-ether.json b/tests/expected_json/locked_ether.locked-ether.json index 1daa8631b..765e4103e 100644 --- a/tests/expected_json/locked_ether.locked-ether.json +++ b/tests/expected_json/locked_ether.locked-ether.json @@ -4,10 +4,6 @@ "results": { "detectors": [ { - "check": "locked-ether", - "impact": "Medium", - "confidence": "High", - "description": "Contract locking ether found in :\n\tContract OnlyLocked has payable functions:\n\t - receive (tests/locked_ether.sol#4-6)\n\tBut does not have a function to withdraw the ether\n", "elements": [ { "type": "contract", @@ -74,7 +70,12 @@ "signature": "receive()" } } - ] + ], + "description": "Contract locking ether found in :\n\tContract OnlyLocked (tests/locked_ether.sol#26) has payable functions:\n\t - Locked.receive() (tests/locked_ether.sol#4-6)\n\tBut does not have a function to withdraw the ether\n", + "markdown": "Contract locking ether found in :\n\tContract [OnlyLocked](tests/locked_ether.sol#L26) has payable functions:\n\t - [Locked.receive()](tests/locked_ether.sol#L4-L6)\n\tBut does not have a function to withdraw the ether\n", + "check": "locked-ether", + "impact": "Medium", + "confidence": "High" } ] } diff --git a/tests/expected_json/locked_ether.locked-ether.txt b/tests/expected_json/locked_ether.locked-ether.txt index a27ff383b..304347703 100644 --- a/tests/expected_json/locked_ether.locked-ether.txt +++ b/tests/expected_json/locked_ether.locked-ether.txt @@ -1,7 +1,7 @@ -INFO:Detectors: + Contract locking ether found in : - Contract OnlyLocked has payable functions: - - receive (tests/locked_ether.sol#4-6) + Contract OnlyLocked (tests/locked_ether.sol#26) has payable functions: + - Locked.receive() (tests/locked_ether.sol#4-6) But does not have a function to withdraw the ether Reference: https://github.com/crytic/slither/wiki/Detector-Documentation#contracts-that-lock-ether -INFO:Slither:tests/locked_ether.sol analyzed (4 contracts), 1 result(s) found +tests/locked_ether.sol analyzed (4 contracts with 1 detectors), 1 result(s) found diff --git a/tests/expected_json/low_level_calls.low-level-calls.json b/tests/expected_json/low_level_calls.low-level-calls.json index 71a20c4fe..f3dd0cf61 100644 --- a/tests/expected_json/low_level_calls.low-level-calls.json +++ b/tests/expected_json/low_level_calls.low-level-calls.json @@ -4,10 +4,6 @@ "results": { "detectors": [ { - "check": "low-level-calls", - "impact": "Informational", - "confidence": "High", - "description": "Low level call in Sender.send(address) (tests/low_level_calls.sol#5-7):\n\t-_receiver.call.value(msg.value).gas(7777)() tests/low_level_calls.sol#6\n", "elements": [ { "type": "function", @@ -119,7 +115,12 @@ } } } - ] + ], + "description": "Low level call in Sender.send(address) (tests/low_level_calls.sol#5-7):\n\t- _receiver.call.value(msg.value).gas(7777)() (tests/low_level_calls.sol#6)\n", + "markdown": "Low level call in [Sender.send(address)](tests/low_level_calls.sol#L5-L7):\n\t- [_receiver.call.value(msg.value).gas(7777)()](tests/low_level_calls.sol#L6)\n", + "check": "low-level-calls", + "impact": "Informational", + "confidence": "High" } ] } diff --git a/tests/expected_json/low_level_calls.low-level-calls.txt b/tests/expected_json/low_level_calls.low-level-calls.txt index db7034d4a..ab94fa3e0 100644 --- a/tests/expected_json/low_level_calls.low-level-calls.txt +++ b/tests/expected_json/low_level_calls.low-level-calls.txt @@ -1,5 +1,5 @@ -INFO:Detectors: + Low level call in Sender.send(address) (tests/low_level_calls.sol#5-7): - -_receiver.call.value(msg.value).gas(7777)() tests/low_level_calls.sol#6 + - _receiver.call.value(msg.value).gas(7777)() (tests/low_level_calls.sol#6) Reference: https://github.com/crytic/slither/wiki/Detector-Documentation#low-level-calls -INFO:Slither:tests/low_level_calls.sol analyzed (2 contracts), 1 result(s) found +tests/low_level_calls.sol analyzed (2 contracts with 1 detectors), 1 result(s) found diff --git a/tests/expected_json/multiple_calls_in_loop.calls-loop.json b/tests/expected_json/multiple_calls_in_loop.calls-loop.json index d08dfb95d..f54be581b 100644 --- a/tests/expected_json/multiple_calls_in_loop.calls-loop.json +++ b/tests/expected_json/multiple_calls_in_loop.calls-loop.json @@ -4,11 +4,64 @@ "results": { "detectors": [ { - "check": "calls-loop", - "impact": "Low", - "confidence": "Medium", - "description": "CallInLoop.bad() has external calls inside a loop: \"destinations[i].transfer(i)\" (tests/multiple_calls_in_loop.sol#11)\n", "elements": [ + { + "type": "function", + "name": "bad", + "source_mapping": { + "start": 153, + "length": 135, + "filename_used": "/home/travis/build/crytic/slither/tests/multiple_calls_in_loop.sol", + "filename_relative": "tests/multiple_calls_in_loop.sol", + "filename_absolute": "/home/travis/build/crytic/slither/tests/multiple_calls_in_loop.sol", + "filename_short": "tests/multiple_calls_in_loop.sol", + "is_dependency": false, + "lines": [ + 9, + 10, + 11, + 12, + 13 + ], + "starting_column": 5, + "ending_column": 6 + }, + "type_specific_fields": { + "parent": { + "type": "contract", + "name": "CallInLoop", + "source_mapping": { + "start": 0, + "length": 291, + "filename_used": "/home/travis/build/crytic/slither/tests/multiple_calls_in_loop.sol", + "filename_relative": "tests/multiple_calls_in_loop.sol", + "filename_absolute": "/home/travis/build/crytic/slither/tests/multiple_calls_in_loop.sol", + "filename_short": "tests/multiple_calls_in_loop.sol", + "is_dependency": false, + "lines": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15 + ], + "starting_column": 1, + "ending_column": 2 + } + }, + "signature": "bad()" + } + }, { "type": "node", "name": "destinations[i].transfer(i)", @@ -86,7 +139,12 @@ } } } - ] + ], + "description": "CallInLoop.bad() (tests/multiple_calls_in_loop.sol#9-13) has external calls inside a loop: destinations[i].transfer(i) (tests/multiple_calls_in_loop.sol#11)\n", + "markdown": "[CallInLoop.bad()](tests/multiple_calls_in_loop.sol#L9-L13) has external calls inside a loop: [destinations[i].transfer(i)](tests/multiple_calls_in_loop.sol#L11)\n", + "check": "calls-loop", + "impact": "Low", + "confidence": "Medium" } ] } diff --git a/tests/expected_json/multiple_calls_in_loop.calls-loop.txt b/tests/expected_json/multiple_calls_in_loop.calls-loop.txt index 7803df6de..1114957d7 100644 --- a/tests/expected_json/multiple_calls_in_loop.calls-loop.txt +++ b/tests/expected_json/multiple_calls_in_loop.calls-loop.txt @@ -1,4 +1,4 @@ -INFO:Detectors: -CallInLoop.bad() has external calls inside a loop: "destinations[i].transfer(i)" (tests/multiple_calls_in_loop.sol#11) -Reference: https://github.com/crytic/slither/wiki/Detector-Documentation/_edit#calls-inside-a-loop -INFO:Slither:tests/multiple_calls_in_loop.sol analyzed (1 contracts), 1 result(s) found + +CallInLoop.bad() (tests/multiple_calls_in_loop.sol#9-13) has external calls inside a loop: destinations[i].transfer(i) (tests/multiple_calls_in_loop.sol#11) +Reference: https://github.com/crytic/slither/wiki/Detector-Documentation/#calls-inside-a-loop +tests/multiple_calls_in_loop.sol analyzed (1 contracts with 1 detectors), 1 result(s) found diff --git a/tests/expected_json/naming_convention.naming-convention.json b/tests/expected_json/naming_convention.naming-convention.json index 794250fcc..b71a64845 100644 --- a/tests/expected_json/naming_convention.naming-convention.json +++ b/tests/expected_json/naming_convention.naming-convention.json @@ -4,10 +4,6 @@ "results": { "detectors": [ { - "check": "naming-convention", - "impact": "Informational", - "confidence": "High", - "description": "Contract 'naming' (tests/naming_convention.sol#3-48) is not in CapWords\n", "elements": [ { "type": "contract", @@ -76,13 +72,14 @@ "convention": "CapWords" } } - ] - }, - { + ], + "description": "Contract naming (tests/naming_convention.sol#3-48) is not in CapWords\n", + "markdown": "Contract [naming](tests/naming_convention.sol#L3-L48) is not in CapWords\n", "check": "naming-convention", "impact": "Informational", - "confidence": "High", - "description": "Struct 'naming.test' (tests/naming_convention.sol#14-16) is not in CapWords\n", + "confidence": "High" + }, + { "elements": [ { "type": "struct", @@ -173,13 +170,14 @@ "convention": "CapWords" } } - ] - }, - { + ], + "description": "Struct naming.test (tests/naming_convention.sol#14-16) is not in CapWords\n", + "markdown": "Struct [naming.test](tests/naming_convention.sol#L14-L16) is not in CapWords\n", "check": "naming-convention", "impact": "Informational", - "confidence": "High", - "description": "Event 'namingevent_(uint256)' (tests/naming_convention.sol#23) is not in CapWords\n", + "confidence": "High" + }, + { "elements": [ { "type": "event", @@ -269,13 +267,14 @@ "convention": "CapWords" } } - ] - }, - { + ], + "description": "Event namingevent_(uint256) (tests/naming_convention.sol#23) is not in CapWords\n", + "markdown": "Event [namingevent_(uint256)](tests/naming_convention.sol#L23) is not in CapWords\n", "check": "naming-convention", "impact": "Informational", - "confidence": "High", - "description": "Function 'naming.GetOne()' (tests/naming_convention.sol#30-33) is not in mixedCase\n", + "confidence": "High" + }, + { "elements": [ { "type": "function", @@ -368,13 +367,14 @@ "convention": "mixedCase" } } - ] - }, - { + ], + "description": "Function naming.GetOne() (tests/naming_convention.sol#30-33) is not in mixedCase\n", + "markdown": "Function [naming.GetOne()](tests/naming_convention.sol#L30-L33) is not in mixedCase\n", "check": "naming-convention", "impact": "Informational", - "confidence": "High", - "description": "Parameter 'Number2' of Number2 (tests/naming_convention.sol#35) is not in mixedCase\n", + "confidence": "High" + }, + { "elements": [ { "type": "variable", @@ -487,13 +487,14 @@ "convention": "mixedCase" } } - ] - }, - { + ], + "description": "Parameter naming.setInt(uint256,uint256).Number2 (tests/naming_convention.sol#35) is not in mixedCase\n", + "markdown": "Parameter [naming.setInt(uint256,uint256).Number2](tests/naming_convention.sol#L35) is not in mixedCase\n", "check": "naming-convention", "impact": "Informational", - "confidence": "High", - "description": "Constant 'naming.MY_other_CONSTANT' (tests/naming_convention.sol#9) is not in UPPER_CASE_WITH_UNDERSCORES\n", + "confidence": "High" + }, + { "elements": [ { "type": "variable", @@ -582,13 +583,14 @@ "convention": "UPPER_CASE_WITH_UNDERSCORES" } } - ] - }, - { + ], + "description": "Constant naming.MY_other_CONSTANT (tests/naming_convention.sol#9) is not in UPPER_CASE_WITH_UNDERSCORES\n", + "markdown": "Constant [naming.MY_other_CONSTANT](tests/naming_convention.sol#L9) is not in UPPER_CASE_WITH_UNDERSCORES\n", "check": "naming-convention", "impact": "Informational", - "confidence": "High", - "description": "Variable 'naming.Var_One' (tests/naming_convention.sol#11) is not in mixedCase\n", + "confidence": "High" + }, + { "elements": [ { "type": "variable", @@ -677,13 +679,14 @@ "convention": "mixedCase" } } - ] - }, - { + ], + "description": "Variable naming.Var_One (tests/naming_convention.sol#11) is not in mixedCase\n", + "markdown": "Variable [naming.Var_One](tests/naming_convention.sol#L11) is not in mixedCase\n", "check": "naming-convention", "impact": "Informational", - "confidence": "High", - "description": "Enum 'naming.numbers' (tests/naming_convention.sol#6) is not in CapWords\n", + "confidence": "High" + }, + { "elements": [ { "type": "enum", @@ -772,13 +775,14 @@ "convention": "CapWords" } } - ] - }, - { + ], + "description": "Enum naming.numbers (tests/naming_convention.sol#6) is not in CapWords\n", + "markdown": "Enum [naming.numbers](tests/naming_convention.sol#L6) is not in CapWords\n", "check": "naming-convention", "impact": "Informational", - "confidence": "High", - "description": "Modifier 'naming.CantDo()' (tests/naming_convention.sol#41-43) is not in mixedCase\n", + "confidence": "High" + }, + { "elements": [ { "type": "function", @@ -870,13 +874,14 @@ "convention": "mixedCase" } } - ] - }, - { + ], + "description": "Modifier naming.CantDo() (tests/naming_convention.sol#41-43) is not in mixedCase\n", + "markdown": "Modifier [naming.CantDo()](tests/naming_convention.sol#L41-L43) is not in mixedCase\n", "check": "naming-convention", "impact": "Informational", - "confidence": "High", - "description": "Parameter '_used' of _used (tests/naming_convention.sol#59) is not in mixedCase\n", + "confidence": "High" + }, + { "elements": [ { "type": "variable", @@ -956,13 +961,14 @@ "convention": "mixedCase" } } - ] - }, - { + ], + "description": "Parameter T.test(uint256,uint256)._used (tests/naming_convention.sol#59) is not in mixedCase\n", + "markdown": "Parameter [T.test(uint256,uint256)._used](tests/naming_convention.sol#L59) is not in mixedCase\n", "check": "naming-convention", "impact": "Informational", - "confidence": "High", - "description": "Variable 'T._myPublicVar' (tests/naming_convention.sol#56) is not in mixedCase\n", + "confidence": "High" + }, + { "elements": [ { "type": "variable", @@ -1020,13 +1026,14 @@ "convention": "mixedCase" } } - ] - }, - { + ], + "description": "Variable T._myPublicVar (tests/naming_convention.sol#56) is not in mixedCase\n", + "markdown": "Variable [T._myPublicVar](tests/naming_convention.sol#L56) is not in mixedCase\n", "check": "naming-convention", "impact": "Informational", - "confidence": "High", - "description": "Variable 'T.l' (tests/naming_convention.sol#67) used l, O, I, which should not be used\n", + "confidence": "High" + }, + { "elements": [ { "type": "variable", @@ -1084,7 +1091,12 @@ "convention": "l_O_I_should_not_be_used" } } - ] + ], + "description": "Variable T.l (tests/naming_convention.sol#67) used l, O, I, which should not be used\n", + "markdown": "Variable [T.l](tests/naming_convention.sol#L67) used l, O, I, which should not be used\n", + "check": "naming-convention", + "impact": "Informational", + "confidence": "High" } ] } diff --git a/tests/expected_json/naming_convention.naming-convention.txt b/tests/expected_json/naming_convention.naming-convention.txt index 25be91780..45c53084c 100644 --- a/tests/expected_json/naming_convention.naming-convention.txt +++ b/tests/expected_json/naming_convention.naming-convention.txt @@ -1,15 +1,15 @@ -INFO:Detectors: -Contract 'naming' (tests/naming_convention.sol#3-48) is not in CapWords -Struct 'naming.test' (tests/naming_convention.sol#14-16) is not in CapWords -Event 'namingevent_(uint256)' (tests/naming_convention.sol#23) is not in CapWords -Function 'naming.GetOne()' (tests/naming_convention.sol#30-33) is not in mixedCase -Parameter 'Number2' of Number2 (tests/naming_convention.sol#35) is not in mixedCase -Constant 'naming.MY_other_CONSTANT' (tests/naming_convention.sol#9) is not in UPPER_CASE_WITH_UNDERSCORES -Variable 'naming.Var_One' (tests/naming_convention.sol#11) is not in mixedCase -Enum 'naming.numbers' (tests/naming_convention.sol#6) is not in CapWords -Modifier 'naming.CantDo()' (tests/naming_convention.sol#41-43) is not in mixedCase -Parameter '_used' of _used (tests/naming_convention.sol#59) is not in mixedCase -Variable 'T._myPublicVar' (tests/naming_convention.sol#56) is not in mixedCase -Variable 'T.l' (tests/naming_convention.sol#67) used l, O, I, which should not be used + +Contract naming (tests/naming_convention.sol#3-48) is not in CapWords +Struct naming.test (tests/naming_convention.sol#14-16) is not in CapWords +Event namingevent_(uint256) (tests/naming_convention.sol#23) is not in CapWords +Function naming.GetOne() (tests/naming_convention.sol#30-33) is not in mixedCase +Parameter naming.setInt(uint256,uint256).Number2 (tests/naming_convention.sol#35) is not in mixedCase +Constant naming.MY_other_CONSTANT (tests/naming_convention.sol#9) is not in UPPER_CASE_WITH_UNDERSCORES +Variable naming.Var_One (tests/naming_convention.sol#11) is not in mixedCase +Enum naming.numbers (tests/naming_convention.sol#6) is not in CapWords +Modifier naming.CantDo() (tests/naming_convention.sol#41-43) is not in mixedCase +Parameter T.test(uint256,uint256)._used (tests/naming_convention.sol#59) is not in mixedCase +Variable T._myPublicVar (tests/naming_convention.sol#56) is not in mixedCase +Variable T.l (tests/naming_convention.sol#67) used l, O, I, which should not be used Reference: https://github.com/crytic/slither/wiki/Detector-Documentation#conformance-to-solidity-naming-conventions -INFO:Slither:tests/naming_convention.sol analyzed (4 contracts), 12 result(s) found +tests/naming_convention.sol analyzed (4 contracts with 1 detectors), 12 result(s) found diff --git a/tests/expected_json/old_solc.sol.json.solc-version.json b/tests/expected_json/old_solc.sol.json.solc-version.json index e9800bc58..716b2e410 100644 --- a/tests/expected_json/old_solc.sol.json.solc-version.json +++ b/tests/expected_json/old_solc.sol.json.solc-version.json @@ -4,10 +4,6 @@ "results": { "detectors": [ { - "check": "solc-version", - "impact": "Informational", - "confidence": "High", - "description": "Pragma version \"0.4.21\" allows old versions (None)\n", "elements": [ { "type": "pragma", @@ -32,7 +28,12 @@ ] } } - ] + ], + "description": "Pragma version0.4.21 (None) allows old versions\n", + "markdown": "Pragma version[0.4.21](None) allows old versions\n", + "check": "solc-version", + "impact": "Informational", + "confidence": "High" } ] } diff --git a/tests/expected_json/old_solc.sol.json.solc-version.txt b/tests/expected_json/old_solc.sol.json.solc-version.txt index 119e34692..e8e4c5ad1 100644 --- a/tests/expected_json/old_solc.sol.json.solc-version.txt +++ b/tests/expected_json/old_solc.sol.json.solc-version.txt @@ -1,5 +1,5 @@ -INFO:Detectors: -Pragma version "0.4.21" allows old versions (None) + +Pragma version0.4.21 (None) allows old versions Reference: https://github.com/crytic/slither/wiki/Detector-Documentation#incorrect-versions-of-solidity +tests/old_solc.sol.json analyzed (1 contracts with 1 detectors), 1 result(s) found INFO:Slither:/home/travis/build/crytic/slither/scripts/../tests/expected_json/old_solc.sol.json.solc-version.json exists already, the overwrite is prevented -INFO:Slither:tests/old_solc.sol.json analyzed (1 contracts), 1 result(s) found diff --git a/tests/expected_json/pragma.0.4.24.pragma.json b/tests/expected_json/pragma.0.4.24.pragma.json index 42a1a4092..6a8687359 100644 --- a/tests/expected_json/pragma.0.4.24.pragma.json +++ b/tests/expected_json/pragma.0.4.24.pragma.json @@ -4,10 +4,6 @@ "results": { "detectors": [ { - "check": "pragma", - "impact": "Informational", - "confidence": "High", - "description": "Different versions of Solidity is used in :\n\t- Version used: ['^0.4.23', '^0.4.24']\n\t- tests/pragma.0.4.23.sol#1 declares pragma solidity^0.4.23\n\t- tests/pragma.0.4.24.sol#1 declares pragma solidity^0.4.24\n", "elements": [ { "type": "pragma", @@ -61,7 +57,12 @@ ] } } - ] + ], + "description": "Different versions of Solidity is used in :\n\t- Version used: ['^0.4.23', '^0.4.24']\n\t- ^0.4.23 (tests/pragma.0.4.23.sol#1)\n\t- ^0.4.24 (tests/pragma.0.4.24.sol#1)\n", + "markdown": "Different versions of Solidity is used in :\n\t- Version used: ['^0.4.23', '^0.4.24']\n\t- [^0.4.23](tests/pragma.0.4.23.sol#L1)\n\t- [^0.4.24](tests/pragma.0.4.24.sol#L1)\n", + "check": "pragma", + "impact": "Informational", + "confidence": "High" } ] } diff --git a/tests/expected_json/pragma.0.4.24.pragma.txt b/tests/expected_json/pragma.0.4.24.pragma.txt index 6961c94cc..8318ed773 100644 --- a/tests/expected_json/pragma.0.4.24.pragma.txt +++ b/tests/expected_json/pragma.0.4.24.pragma.txt @@ -1,7 +1,7 @@ -INFO:Detectors: + Different versions of Solidity is used in : - Version used: ['^0.4.23', '^0.4.24'] - - tests/pragma.0.4.23.sol#1 declares pragma solidity^0.4.23 - - tests/pragma.0.4.24.sol#1 declares pragma solidity^0.4.24 + - ^0.4.23 (tests/pragma.0.4.23.sol#1) + - ^0.4.24 (tests/pragma.0.4.24.sol#1) Reference: https://github.com/crytic/slither/wiki/Detector-Documentation#different-pragma-directives-are-used -INFO:Slither:tests/pragma.0.4.24.sol analyzed (1 contracts), 1 result(s) found +tests/pragma.0.4.24.sol analyzed (1 contracts with 1 detectors), 1 result(s) found diff --git a/tests/expected_json/reentrancy-0.5.1.reentrancy-eth.json b/tests/expected_json/reentrancy-0.5.1.reentrancy-eth.json index 32cc329fc..7923f8ed2 100644 --- a/tests/expected_json/reentrancy-0.5.1.reentrancy-eth.json +++ b/tests/expected_json/reentrancy-0.5.1.reentrancy-eth.json @@ -4,10 +4,6 @@ "results": { "detectors": [ { - "check": "reentrancy-eth", - "impact": "High", - "confidence": "Medium", - "description": "Reentrancy in Reentrancy.withdrawBalance() (tests/reentrancy-0.5.1.sol#14-22):\n\tExternal calls:\n\t- (ret,mem) = msg.sender.call.value(userBalance[msg.sender])() (tests/reentrancy-0.5.1.sol#17)\n\tState variables written after the call(s):\n\t- userBalance (tests/reentrancy-0.5.1.sol#21)\n", "elements": [ { "type": "function", @@ -350,13 +346,14 @@ "variable_name": "userBalance" } } - ] - }, - { + ], + "description": "Reentrancy in Reentrancy.withdrawBalance() (tests/reentrancy-0.5.1.sol#14-22):\n\tExternal calls:\n\t- (ret,mem) = msg.sender.call.value(userBalance[msg.sender])() (tests/reentrancy-0.5.1.sol#17)\n\tState variables written after the call(s):\n\t- Reentrancy.userBalance (tests/reentrancy-0.5.1.sol#4) in userBalance[msg.sender] = 0 (tests/reentrancy-0.5.1.sol#21)\n", + "markdown": "Reentrancy in [Reentrancy.withdrawBalance()](tests/reentrancy-0.5.1.sol#L14-L22):\n\tExternal calls:\n\t- [(ret,mem) = msg.sender.call.value(userBalance[msg.sender])()](tests/reentrancy-0.5.1.sol#L17)\n\tState variables written after the call(s):\n\t- [Reentrancy.userBalance](tests/reentrancy-0.5.1.sol#L4) in [userBalance[msg.sender] = 0](tests/reentrancy-0.5.1.sol#L21)\n", "check": "reentrancy-eth", "impact": "High", - "confidence": "Medium", - "description": "Reentrancy in Reentrancy.withdrawBalance_fixed_3() (tests/reentrancy-0.5.1.sol#44-53):\n\tExternal calls:\n\t- (ret,mem) = msg.sender.call.value(amount)() (tests/reentrancy-0.5.1.sol#49)\n\tState variables written after the call(s):\n\t- userBalance (tests/reentrancy-0.5.1.sol#51)\n", + "confidence": "Medium" + }, + { "elements": [ { "type": "function", @@ -702,7 +699,12 @@ "variable_name": "userBalance" } } - ] + ], + "description": "Reentrancy in Reentrancy.withdrawBalance_fixed_3() (tests/reentrancy-0.5.1.sol#44-53):\n\tExternal calls:\n\t- (ret,mem) = msg.sender.call.value(amount)() (tests/reentrancy-0.5.1.sol#49)\n\tState variables written after the call(s):\n\t- Reentrancy.userBalance (tests/reentrancy-0.5.1.sol#4) in userBalance[msg.sender] = amount (tests/reentrancy-0.5.1.sol#51)\n", + "markdown": "Reentrancy in [Reentrancy.withdrawBalance_fixed_3()](tests/reentrancy-0.5.1.sol#L44-L53):\n\tExternal calls:\n\t- [(ret,mem) = msg.sender.call.value(amount)()](tests/reentrancy-0.5.1.sol#L49)\n\tState variables written after the call(s):\n\t- [Reentrancy.userBalance](tests/reentrancy-0.5.1.sol#L4) in [userBalance[msg.sender] = amount](tests/reentrancy-0.5.1.sol#L51)\n", + "check": "reentrancy-eth", + "impact": "High", + "confidence": "Medium" } ] } diff --git a/tests/expected_json/reentrancy-0.5.1.reentrancy-eth.txt b/tests/expected_json/reentrancy-0.5.1.reentrancy-eth.txt index ebf2a8c52..7f98e13f9 100644 --- a/tests/expected_json/reentrancy-0.5.1.reentrancy-eth.txt +++ b/tests/expected_json/reentrancy-0.5.1.reentrancy-eth.txt @@ -1,13 +1,13 @@ -INFO:Detectors: + Reentrancy in Reentrancy.withdrawBalance() (tests/reentrancy-0.5.1.sol#14-22): External calls: - (ret,mem) = msg.sender.call.value(userBalance[msg.sender])() (tests/reentrancy-0.5.1.sol#17) State variables written after the call(s): - - userBalance (tests/reentrancy-0.5.1.sol#21) + - Reentrancy.userBalance (tests/reentrancy-0.5.1.sol#4) in userBalance[msg.sender] = 0 (tests/reentrancy-0.5.1.sol#21) Reentrancy in Reentrancy.withdrawBalance_fixed_3() (tests/reentrancy-0.5.1.sol#44-53): External calls: - (ret,mem) = msg.sender.call.value(amount)() (tests/reentrancy-0.5.1.sol#49) State variables written after the call(s): - - userBalance (tests/reentrancy-0.5.1.sol#51) + - Reentrancy.userBalance (tests/reentrancy-0.5.1.sol#4) in userBalance[msg.sender] = amount (tests/reentrancy-0.5.1.sol#51) Reference: https://github.com/crytic/slither/wiki/Detector-Documentation#reentrancy-vulnerabilities -INFO:Slither:tests/reentrancy-0.5.1.sol analyzed (1 contracts), 2 result(s) found +tests/reentrancy-0.5.1.sol analyzed (1 contracts with 1 detectors), 2 result(s) found diff --git a/tests/expected_json/reentrancy.reentrancy-eth.json b/tests/expected_json/reentrancy.reentrancy-eth.json index cf7f5ae09..2f403e06e 100644 --- a/tests/expected_json/reentrancy.reentrancy-eth.json +++ b/tests/expected_json/reentrancy.reentrancy-eth.json @@ -4,10 +4,6 @@ "results": { "detectors": [ { - "check": "reentrancy-eth", - "impact": "High", - "confidence": "Medium", - "description": "Reentrancy in Reentrancy.withdrawBalance() (tests/reentrancy.sol#14-21):\n\tExternal calls:\n\t- ! (msg.sender.call.value(userBalance[msg.sender])()) (tests/reentrancy.sol#17)\n\tState variables written after the call(s):\n\t- userBalance (tests/reentrancy.sol#20)\n", "elements": [ { "type": "function", @@ -401,13 +397,14 @@ "variable_name": "userBalance" } } - ] - }, - { + ], + "description": "Reentrancy in Reentrancy.withdrawBalance() (tests/reentrancy.sol#14-21):\n\tExternal calls:\n\t- ! (msg.sender.call.value(userBalance[msg.sender])()) (tests/reentrancy.sol#17)\n\tState variables written after the call(s):\n\t- Reentrancy.userBalance (tests/reentrancy.sol#4) in userBalance[msg.sender] = 0 (tests/reentrancy.sol#20)\n", + "markdown": "Reentrancy in [Reentrancy.withdrawBalance()](tests/reentrancy.sol#L14-L21):\n\tExternal calls:\n\t- [! (msg.sender.call.value(userBalance[msg.sender])())](tests/reentrancy.sol#L17)\n\tState variables written after the call(s):\n\t- [Reentrancy.userBalance](tests/reentrancy.sol#L4) in [userBalance[msg.sender] = 0](tests/reentrancy.sol#L20)\n", "check": "reentrancy-eth", "impact": "High", - "confidence": "Medium", - "description": "Reentrancy in Reentrancy.withdrawBalance_nested() (tests/reentrancy.sol#64-70):\n\tExternal calls:\n\t- msg.sender.call.value(amount / 2)() (tests/reentrancy.sol#67)\n\tState variables written after the call(s):\n\t- userBalance (tests/reentrancy.sol#68)\n", + "confidence": "Medium" + }, + { "elements": [ { "type": "function", @@ -798,7 +795,12 @@ "variable_name": "userBalance" } } - ] + ], + "description": "Reentrancy in Reentrancy.withdrawBalance_nested() (tests/reentrancy.sol#64-70):\n\tExternal calls:\n\t- msg.sender.call.value(amount / 2)() (tests/reentrancy.sol#67)\n\tState variables written after the call(s):\n\t- Reentrancy.userBalance (tests/reentrancy.sol#4) in userBalance[msg.sender] = 0 (tests/reentrancy.sol#68)\n", + "markdown": "Reentrancy in [Reentrancy.withdrawBalance_nested()](tests/reentrancy.sol#L64-L70):\n\tExternal calls:\n\t- [msg.sender.call.value(amount / 2)()](tests/reentrancy.sol#L67)\n\tState variables written after the call(s):\n\t- [Reentrancy.userBalance](tests/reentrancy.sol#L4) in [userBalance[msg.sender] = 0](tests/reentrancy.sol#L68)\n", + "check": "reentrancy-eth", + "impact": "High", + "confidence": "Medium" } ] } diff --git a/tests/expected_json/reentrancy.reentrancy-eth.txt b/tests/expected_json/reentrancy.reentrancy-eth.txt index e1160ca4c..f5ab77567 100644 --- a/tests/expected_json/reentrancy.reentrancy-eth.txt +++ b/tests/expected_json/reentrancy.reentrancy-eth.txt @@ -1,13 +1,13 @@ -INFO:Detectors: + Reentrancy in Reentrancy.withdrawBalance() (tests/reentrancy.sol#14-21): External calls: - ! (msg.sender.call.value(userBalance[msg.sender])()) (tests/reentrancy.sol#17) State variables written after the call(s): - - userBalance (tests/reentrancy.sol#20) + - Reentrancy.userBalance (tests/reentrancy.sol#4) in userBalance[msg.sender] = 0 (tests/reentrancy.sol#20) Reentrancy in Reentrancy.withdrawBalance_nested() (tests/reentrancy.sol#64-70): External calls: - msg.sender.call.value(amount / 2)() (tests/reentrancy.sol#67) State variables written after the call(s): - - userBalance (tests/reentrancy.sol#68) + - Reentrancy.userBalance (tests/reentrancy.sol#4) in userBalance[msg.sender] = 0 (tests/reentrancy.sol#68) Reference: https://github.com/crytic/slither/wiki/Detector-Documentation#reentrancy-vulnerabilities -INFO:Slither:tests/reentrancy.sol analyzed (1 contracts), 2 result(s) found +tests/reentrancy.sol analyzed (1 contracts with 1 detectors), 2 result(s) found diff --git a/tests/expected_json/right_to_left_override.rtlo.json b/tests/expected_json/right_to_left_override.rtlo.json index c189dbcd7..e7540f466 100644 --- a/tests/expected_json/right_to_left_override.rtlo.json +++ b/tests/expected_json/right_to_left_override.rtlo.json @@ -4,10 +4,6 @@ "results": { "detectors": [ { - "check": "rtlo", - "impact": "High", - "confidence": "High", - "description": "/home/travis/build/crytic/slither/tests/right_to_left_override.sol contains a unicode right-to-left-override character at byte offset 96:\n\t- b' test1(/*A\\xe2\\x80\\xae/*B*/2 , 1/*\\xe2\\x80\\xad'\n", "elements": [ { "type": "other", @@ -27,7 +23,12 @@ "ending_column": 21 } } - ] + ], + "description": "/home/travis/build/crytic/slither/tests/right_to_left_override.sol contains a unicode right-to-left-override character at byte offset 96:\n\t- b' test1(/*A\\xe2\\x80\\xae/*B*/2 , 1/*\\xe2\\x80\\xad'\n", + "markdown": "/home/travis/build/crytic/slither/tests/right_to_left_override.sol contains a unicode right-to-left-override character at byte offset 96:\n\t- b' test1(/*A\\xe2\\x80\\xae/*B*/2 , 1/*\\xe2\\x80\\xad'\n", + "check": "rtlo", + "impact": "High", + "confidence": "High" } ] } diff --git a/tests/expected_json/right_to_left_override.rtlo.txt b/tests/expected_json/right_to_left_override.rtlo.txt index 9d77008f0..29326d789 100644 --- a/tests/expected_json/right_to_left_override.rtlo.txt +++ b/tests/expected_json/right_to_left_override.rtlo.txt @@ -1,5 +1,5 @@ -INFO:Detectors: + /home/travis/build/crytic/slither/tests/right_to_left_override.sol contains a unicode right-to-left-override character at byte offset 96: - b' test1(/*A\xe2\x80\xae/*B*/2 , 1/*\xe2\x80\xad' Reference: https://github.com/crytic/slither/wiki/Detector-Documentation#right-to-left-override-character -INFO:Slither:tests/right_to_left_override.sol analyzed (1 contracts), 1 result(s) found +tests/right_to_left_override.sol analyzed (1 contracts with 1 detectors), 1 result(s) found diff --git a/tests/expected_json/shadowing_abstract.shadowing-abstract.json b/tests/expected_json/shadowing_abstract.shadowing-abstract.json index ec993de29..c83b58049 100644 --- a/tests/expected_json/shadowing_abstract.shadowing-abstract.json +++ b/tests/expected_json/shadowing_abstract.shadowing-abstract.json @@ -4,10 +4,6 @@ "results": { "detectors": [ { - "check": "shadowing-abstract", - "impact": "Medium", - "confidence": "High", - "description": "DerivedContract.owner (tests/shadowing_abstract.sol#7) shadows:\n\t- BaseContract.owner (tests/shadowing_abstract.sol#2)\n", "elements": [ { "type": "variable", @@ -91,7 +87,12 @@ } } } - ] + ], + "description": "DerivedContract.owner (tests/shadowing_abstract.sol#7) shadows:\n\t- BaseContract.owner (tests/shadowing_abstract.sol#2)\n", + "markdown": "[DerivedContract.owner](tests/shadowing_abstract.sol#L7) shadows:\n\t- [BaseContract.owner](tests/shadowing_abstract.sol#L2)\n", + "check": "shadowing-abstract", + "impact": "Medium", + "confidence": "High" } ] } diff --git a/tests/expected_json/shadowing_abstract.shadowing-abstract.txt b/tests/expected_json/shadowing_abstract.shadowing-abstract.txt index fed0e9e24..93b722f63 100644 --- a/tests/expected_json/shadowing_abstract.shadowing-abstract.txt +++ b/tests/expected_json/shadowing_abstract.shadowing-abstract.txt @@ -1,5 +1,5 @@ -INFO:Detectors: + DerivedContract.owner (tests/shadowing_abstract.sol#7) shadows: - BaseContract.owner (tests/shadowing_abstract.sol#2) Reference: https://github.com/crytic/slither/wiki/Detector-Documentation#state-variable-shadowing-from-abstract-contracts -INFO:Slither:tests/shadowing_abstract.sol analyzed (2 contracts), 1 result(s) found +tests/shadowing_abstract.sol analyzed (2 contracts with 1 detectors), 1 result(s) found diff --git a/tests/expected_json/shadowing_builtin_symbols.shadowing-builtin.json b/tests/expected_json/shadowing_builtin_symbols.shadowing-builtin.json index a328fa79a..771dac106 100644 --- a/tests/expected_json/shadowing_builtin_symbols.shadowing-builtin.json +++ b/tests/expected_json/shadowing_builtin_symbols.shadowing-builtin.json @@ -4,10 +4,6 @@ "results": { "detectors": [ { - "check": "shadowing-builtin", - "impact": "Low", - "confidence": "High", - "description": "BaseContract.blockhash (state variable @ tests/shadowing_builtin_symbols.sol#4) shadows built-in symbol \"blockhash\"\n", "elements": [ { "type": "variable", @@ -52,13 +48,14 @@ } } } - ] - }, - { + ], + "description": "BaseContract.blockhash (tests/shadowing_builtin_symbols.sol#4) (state variable) shadows built-in symbol\"\n", + "markdown": "[BaseContract.blockhash](tests/shadowing_builtin_symbols.sol#L4) (state variable) shadows built-in symbol\"\n", "check": "shadowing-builtin", "impact": "Low", - "confidence": "High", - "description": "BaseContract.now (state variable @ tests/shadowing_builtin_symbols.sol#5) shadows built-in symbol \"now\"\n", + "confidence": "High" + }, + { "elements": [ { "type": "variable", @@ -103,13 +100,14 @@ } } } - ] - }, - { + ], + "description": "BaseContract.now (tests/shadowing_builtin_symbols.sol#5) (state variable) shadows built-in symbol\"\n", + "markdown": "[BaseContract.now](tests/shadowing_builtin_symbols.sol#L5) (state variable) shadows built-in symbol\"\n", "check": "shadowing-builtin", "impact": "Low", - "confidence": "High", - "description": "BaseContract.revert (event @ tests/shadowing_builtin_symbols.sol#7) shadows built-in symbol \"revert\"\n", + "confidence": "High" + }, + { "elements": [ { "type": "event", @@ -155,13 +153,14 @@ "signature": "revert(bool)" } } - ] - }, - { + ], + "description": "BaseContractrevert(bool) (tests/shadowing_builtin_symbols.sol#7) (event) shadows built-in symbol\"\n", + "markdown": "[BaseContractrevert(bool)](tests/shadowing_builtin_symbols.sol#L7) (event) shadows built-in symbol\"\n", "check": "shadowing-builtin", "impact": "Low", - "confidence": "High", - "description": "ExtendedContract.assert (function @ tests/shadowing_builtin_symbols.sol#13-15) shadows built-in symbol \"assert\"\n", + "confidence": "High" + }, + { "elements": [ { "type": "function", @@ -210,13 +209,14 @@ "signature": "assert(bool)" } } - ] - }, - { + ], + "description": "ExtendedContract.assert(bool) (tests/shadowing_builtin_symbols.sol#13-15) (function) shadows built-in symbol\"\n", + "markdown": "[ExtendedContract.assert(bool)](tests/shadowing_builtin_symbols.sol#L13-L15) (function) shadows built-in symbol\"\n", "check": "shadowing-builtin", "impact": "Low", - "confidence": "High", - "description": "ExtendedContract.assert.msg (local variable @ tests/shadowing_builtin_symbols.sol#14) shadows built-in symbol \"msg\"\n", + "confidence": "High" + }, + { "elements": [ { "type": "variable", @@ -285,13 +285,14 @@ } } } - ] - }, - { + ], + "description": "ExtendedContract.assert(bool).msg (tests/shadowing_builtin_symbols.sol#14) (local variable) shadows built-in symbol\"\n", + "markdown": "[ExtendedContract.assert(bool).msg](tests/shadowing_builtin_symbols.sol#L14) (local variable) shadows built-in symbol\"\n", "check": "shadowing-builtin", "impact": "Low", - "confidence": "High", - "description": "ExtendedContract.ecrecover (state variable @ tests/shadowing_builtin_symbols.sol#11) shadows built-in symbol \"ecrecover\"\n", + "confidence": "High" + }, + { "elements": [ { "type": "variable", @@ -337,13 +338,14 @@ } } } - ] - }, - { + ], + "description": "ExtendedContract.ecrecover (tests/shadowing_builtin_symbols.sol#11) (state variable) shadows built-in symbol\"\n", + "markdown": "[ExtendedContract.ecrecover](tests/shadowing_builtin_symbols.sol#L11) (state variable) shadows built-in symbol\"\n", "check": "shadowing-builtin", "impact": "Low", - "confidence": "High", - "description": "FurtherExtendedContract.require (modifier @ tests/shadowing_builtin_symbols.sol#23-28) shadows built-in symbol \"require\"\n", + "confidence": "High" + }, + { "elements": [ { "type": "function", @@ -400,13 +402,14 @@ "signature": "require()" } } - ] - }, - { + ], + "description": "FurtherExtendedContract.require() (tests/shadowing_builtin_symbols.sol#23-28) (modifier) shadows built-in symbol\"\n", + "markdown": "[FurtherExtendedContract.require()](tests/shadowing_builtin_symbols.sol#L23-L28) (modifier) shadows built-in symbol\"\n", "check": "shadowing-builtin", "impact": "Low", - "confidence": "High", - "description": "FurtherExtendedContract.require.keccak256 (local variable @ tests/shadowing_builtin_symbols.sol#25) shadows built-in symbol \"keccak256\"\n", + "confidence": "High" + }, + { "elements": [ { "type": "variable", @@ -483,13 +486,14 @@ } } } - ] - }, - { + ], + "description": "FurtherExtendedContract.require().keccak256 (tests/shadowing_builtin_symbols.sol#25) (local variable) shadows built-in symbol\"\n", + "markdown": "[FurtherExtendedContract.require().keccak256](tests/shadowing_builtin_symbols.sol#L25) (local variable) shadows built-in symbol\"\n", "check": "shadowing-builtin", "impact": "Low", - "confidence": "High", - "description": "FurtherExtendedContract.require.sha3 (local variable @ tests/shadowing_builtin_symbols.sol#26) shadows built-in symbol \"sha3\"\n", + "confidence": "High" + }, + { "elements": [ { "type": "variable", @@ -566,13 +570,14 @@ } } } - ] - }, - { + ], + "description": "FurtherExtendedContract.require().sha3 (tests/shadowing_builtin_symbols.sol#26) (local variable) shadows built-in symbol\"\n", + "markdown": "[FurtherExtendedContract.require().sha3](tests/shadowing_builtin_symbols.sol#L26) (local variable) shadows built-in symbol\"\n", "check": "shadowing-builtin", "impact": "Low", - "confidence": "High", - "description": "FurtherExtendedContract.blockhash (state variable @ tests/shadowing_builtin_symbols.sol#19) shadows built-in symbol \"blockhash\"\n", + "confidence": "High" + }, + { "elements": [ { "type": "variable", @@ -623,13 +628,14 @@ } } } - ] - }, - { + ], + "description": "FurtherExtendedContract.blockhash (tests/shadowing_builtin_symbols.sol#19) (state variable) shadows built-in symbol\"\n", + "markdown": "[FurtherExtendedContract.blockhash](tests/shadowing_builtin_symbols.sol#L19) (state variable) shadows built-in symbol\"\n", "check": "shadowing-builtin", "impact": "Low", - "confidence": "High", - "description": "FurtherExtendedContract.this (state variable @ tests/shadowing_builtin_symbols.sol#20) shadows built-in symbol \"this\"\n", + "confidence": "High" + }, + { "elements": [ { "type": "variable", @@ -680,13 +686,14 @@ } } } - ] - }, - { + ], + "description": "FurtherExtendedContract.this (tests/shadowing_builtin_symbols.sol#20) (state variable) shadows built-in symbol\"\n", + "markdown": "[FurtherExtendedContract.this](tests/shadowing_builtin_symbols.sol#L20) (state variable) shadows built-in symbol\"\n", "check": "shadowing-builtin", "impact": "Low", - "confidence": "High", - "description": "FurtherExtendedContract.abi (state variable @ tests/shadowing_builtin_symbols.sol#21) shadows built-in symbol \"abi\"\n", + "confidence": "High" + }, + { "elements": [ { "type": "variable", @@ -737,13 +744,14 @@ } } } - ] - }, - { + ], + "description": "FurtherExtendedContract.abi (tests/shadowing_builtin_symbols.sol#21) (state variable) shadows built-in symbol\"\n", + "markdown": "[FurtherExtendedContract.abi](tests/shadowing_builtin_symbols.sol#L21) (state variable) shadows built-in symbol\"\n", "check": "shadowing-builtin", "impact": "Low", - "confidence": "High", - "description": "Reserved.mutable (state variable @ tests/shadowing_builtin_symbols.sol#32) shadows built-in symbol \"mutable\"\n", + "confidence": "High" + }, + { "elements": [ { "type": "variable", @@ -786,7 +794,12 @@ } } } - ] + ], + "description": "Reserved.mutable (tests/shadowing_builtin_symbols.sol#32) (state variable) shadows built-in symbol\"\n", + "markdown": "[Reserved.mutable](tests/shadowing_builtin_symbols.sol#L32) (state variable) shadows built-in symbol\"\n", + "check": "shadowing-builtin", + "impact": "Low", + "confidence": "High" } ] } diff --git a/tests/expected_json/shadowing_builtin_symbols.shadowing-builtin.txt b/tests/expected_json/shadowing_builtin_symbols.shadowing-builtin.txt index 18d9c370a..18473dd98 100644 --- a/tests/expected_json/shadowing_builtin_symbols.shadowing-builtin.txt +++ b/tests/expected_json/shadowing_builtin_symbols.shadowing-builtin.txt @@ -1,16 +1,16 @@ -INFO:Detectors: -BaseContract.blockhash (state variable @ tests/shadowing_builtin_symbols.sol#4) shadows built-in symbol "blockhash" -BaseContract.now (state variable @ tests/shadowing_builtin_symbols.sol#5) shadows built-in symbol "now" -BaseContract.revert (event @ tests/shadowing_builtin_symbols.sol#7) shadows built-in symbol "revert" -ExtendedContract.assert (function @ tests/shadowing_builtin_symbols.sol#13-15) shadows built-in symbol "assert" -ExtendedContract.assert.msg (local variable @ tests/shadowing_builtin_symbols.sol#14) shadows built-in symbol "msg" -ExtendedContract.ecrecover (state variable @ tests/shadowing_builtin_symbols.sol#11) shadows built-in symbol "ecrecover" -FurtherExtendedContract.require (modifier @ tests/shadowing_builtin_symbols.sol#23-28) shadows built-in symbol "require" -FurtherExtendedContract.require.keccak256 (local variable @ tests/shadowing_builtin_symbols.sol#25) shadows built-in symbol "keccak256" -FurtherExtendedContract.require.sha3 (local variable @ tests/shadowing_builtin_symbols.sol#26) shadows built-in symbol "sha3" -FurtherExtendedContract.blockhash (state variable @ tests/shadowing_builtin_symbols.sol#19) shadows built-in symbol "blockhash" -FurtherExtendedContract.this (state variable @ tests/shadowing_builtin_symbols.sol#20) shadows built-in symbol "this" -FurtherExtendedContract.abi (state variable @ tests/shadowing_builtin_symbols.sol#21) shadows built-in symbol "abi" -Reserved.mutable (state variable @ tests/shadowing_builtin_symbols.sol#32) shadows built-in symbol "mutable" + +BaseContract.blockhash (tests/shadowing_builtin_symbols.sol#4) (state variable) shadows built-in symbol" +BaseContract.now (tests/shadowing_builtin_symbols.sol#5) (state variable) shadows built-in symbol" +BaseContractrevert(bool) (tests/shadowing_builtin_symbols.sol#7) (event) shadows built-in symbol" +ExtendedContract.assert(bool) (tests/shadowing_builtin_symbols.sol#13-15) (function) shadows built-in symbol" +ExtendedContract.assert(bool).msg (tests/shadowing_builtin_symbols.sol#14) (local variable) shadows built-in symbol" +ExtendedContract.ecrecover (tests/shadowing_builtin_symbols.sol#11) (state variable) shadows built-in symbol" +FurtherExtendedContract.require() (tests/shadowing_builtin_symbols.sol#23-28) (modifier) shadows built-in symbol" +FurtherExtendedContract.require().keccak256 (tests/shadowing_builtin_symbols.sol#25) (local variable) shadows built-in symbol" +FurtherExtendedContract.require().sha3 (tests/shadowing_builtin_symbols.sol#26) (local variable) shadows built-in symbol" +FurtherExtendedContract.blockhash (tests/shadowing_builtin_symbols.sol#19) (state variable) shadows built-in symbol" +FurtherExtendedContract.this (tests/shadowing_builtin_symbols.sol#20) (state variable) shadows built-in symbol" +FurtherExtendedContract.abi (tests/shadowing_builtin_symbols.sol#21) (state variable) shadows built-in symbol" +Reserved.mutable (tests/shadowing_builtin_symbols.sol#32) (state variable) shadows built-in symbol" Reference: https://github.com/crytic/slither/wiki/Detector-Documentation#builtin-symbol-shadowing -INFO:Slither:tests/shadowing_builtin_symbols.sol analyzed (4 contracts), 13 result(s) found +tests/shadowing_builtin_symbols.sol analyzed (4 contracts with 1 detectors), 13 result(s) found diff --git a/tests/expected_json/shadowing_local_variable.shadowing-local.json b/tests/expected_json/shadowing_local_variable.shadowing-local.json index 616a637df..407cdbfb5 100644 --- a/tests/expected_json/shadowing_local_variable.shadowing-local.json +++ b/tests/expected_json/shadowing_local_variable.shadowing-local.json @@ -4,10 +4,6 @@ "results": { "detectors": [ { - "check": "shadowing-local", - "impact": "Low", - "confidence": "High", - "description": "FurtherExtendedContract.shadowingParent.x (local variable @ tests/shadowing_local_variable.sol#25) shadows:\n\t- FurtherExtendedContract.x (state variable @ tests/shadowing_local_variable.sol#17)\n\t- ExtendedContract.x (state variable @ tests/shadowing_local_variable.sol#9)\n\t- BaseContract.x (state variable @ tests/shadowing_local_variable.sol#4)\n", "elements": [ { "type": "variable", @@ -211,13 +207,14 @@ } } } - ] - }, - { + ], + "description": "FurtherExtendedContract.shadowingParent(uint256).x (tests/shadowing_local_variable.sol#25) shadows:\n\t- FurtherExtendedContract.x (tests/shadowing_local_variable.sol#17) (state variable)\n\t- ExtendedContract.x (tests/shadowing_local_variable.sol#9) (state variable)\n\t- BaseContract.x (tests/shadowing_local_variable.sol#4) (state variable)\n", + "markdown": "[FurtherExtendedContract.shadowingParent(uint256).x](tests/shadowing_local_variable.sol#L25) shadows:\n\t- [FurtherExtendedContract.x](tests/shadowing_local_variable.sol#L17) (state variable)\n\t- [ExtendedContract.x](tests/shadowing_local_variable.sol#L9) (state variable)\n\t- [BaseContract.x](tests/shadowing_local_variable.sol#L4) (state variable)\n", "check": "shadowing-local", "impact": "Low", - "confidence": "High", - "description": "FurtherExtendedContract.shadowingParent.y (local variable @ tests/shadowing_local_variable.sol#25) shadows:\n\t- BaseContract.y (state variable @ tests/shadowing_local_variable.sol#5)\n", + "confidence": "High" + }, + { "elements": [ { "type": "variable", @@ -329,13 +326,14 @@ } } } - ] - }, - { + ], + "description": "FurtherExtendedContract.shadowingParent(uint256).y (tests/shadowing_local_variable.sol#25) shadows:\n\t- BaseContract.y (tests/shadowing_local_variable.sol#5) (state variable)\n", + "markdown": "[FurtherExtendedContract.shadowingParent(uint256).y](tests/shadowing_local_variable.sol#L25) shadows:\n\t- [BaseContract.y](tests/shadowing_local_variable.sol#L5) (state variable)\n", "check": "shadowing-local", "impact": "Low", - "confidence": "High", - "description": "FurtherExtendedContract.shadowingParent.z (local variable @ tests/shadowing_local_variable.sol#25) shadows:\n\t- ExtendedContract.z (function @ tests/shadowing_local_variable.sol#11)\n", + "confidence": "High" + }, + { "elements": [ { "type": "variable", @@ -451,13 +449,14 @@ "signature": "z()" } } - ] - }, - { + ], + "description": "FurtherExtendedContract.shadowingParent(uint256).z (tests/shadowing_local_variable.sol#25) shadows:\n\t- ExtendedContract.z() (tests/shadowing_local_variable.sol#11) (function)\n", + "markdown": "[FurtherExtendedContract.shadowingParent(uint256).z](tests/shadowing_local_variable.sol#L25) shadows:\n\t- [ExtendedContract.z()](tests/shadowing_local_variable.sol#L11) (function)\n", "check": "shadowing-local", "impact": "Low", - "confidence": "High", - "description": "FurtherExtendedContract.shadowingParent.w (local variable @ tests/shadowing_local_variable.sol#25) shadows:\n\t- FurtherExtendedContract.w (modifier @ tests/shadowing_local_variable.sol#20-23)\n", + "confidence": "High" + }, + { "elements": [ { "type": "variable", @@ -580,13 +579,14 @@ "signature": "w()" } } - ] - }, - { + ], + "description": "FurtherExtendedContract.shadowingParent(uint256).w (tests/shadowing_local_variable.sol#25) shadows:\n\t- FurtherExtendedContract.w() (tests/shadowing_local_variable.sol#20-23) (modifier)\n", + "markdown": "[FurtherExtendedContract.shadowingParent(uint256).w](tests/shadowing_local_variable.sol#L25) shadows:\n\t- [FurtherExtendedContract.w()](tests/shadowing_local_variable.sol#L20-L23) (modifier)\n", "check": "shadowing-local", "impact": "Low", - "confidence": "High", - "description": "FurtherExtendedContract.shadowingParent.v (local variable @ tests/shadowing_local_variable.sol#25) shadows:\n\t- ExtendedContract.v (event @ tests/shadowing_local_variable.sol#13)\n", + "confidence": "High" + }, + { "elements": [ { "type": "variable", @@ -702,7 +702,12 @@ "signature": "v()" } } - ] + ], + "description": "FurtherExtendedContract.shadowingParent(uint256).v (tests/shadowing_local_variable.sol#25) shadows:\n\t- ExtendedContractv() (tests/shadowing_local_variable.sol#13) (event)\n", + "markdown": "[FurtherExtendedContract.shadowingParent(uint256).v](tests/shadowing_local_variable.sol#L25) shadows:\n\t- [ExtendedContractv()](tests/shadowing_local_variable.sol#L13) (event)\n", + "check": "shadowing-local", + "impact": "Low", + "confidence": "High" } ] } diff --git a/tests/expected_json/shadowing_local_variable.shadowing-local.txt b/tests/expected_json/shadowing_local_variable.shadowing-local.txt index 944c3bd1b..40eb29c54 100644 --- a/tests/expected_json/shadowing_local_variable.shadowing-local.txt +++ b/tests/expected_json/shadowing_local_variable.shadowing-local.txt @@ -1,15 +1,15 @@ -INFO:Detectors: -FurtherExtendedContract.shadowingParent.x (local variable @ tests/shadowing_local_variable.sol#25) shadows: - - FurtherExtendedContract.x (state variable @ tests/shadowing_local_variable.sol#17) - - ExtendedContract.x (state variable @ tests/shadowing_local_variable.sol#9) - - BaseContract.x (state variable @ tests/shadowing_local_variable.sol#4) -FurtherExtendedContract.shadowingParent.y (local variable @ tests/shadowing_local_variable.sol#25) shadows: - - BaseContract.y (state variable @ tests/shadowing_local_variable.sol#5) -FurtherExtendedContract.shadowingParent.z (local variable @ tests/shadowing_local_variable.sol#25) shadows: - - ExtendedContract.z (function @ tests/shadowing_local_variable.sol#11) -FurtherExtendedContract.shadowingParent.w (local variable @ tests/shadowing_local_variable.sol#25) shadows: - - FurtherExtendedContract.w (modifier @ tests/shadowing_local_variable.sol#20-23) -FurtherExtendedContract.shadowingParent.v (local variable @ tests/shadowing_local_variable.sol#25) shadows: - - ExtendedContract.v (event @ tests/shadowing_local_variable.sol#13) + +FurtherExtendedContract.shadowingParent(uint256).x (tests/shadowing_local_variable.sol#25) shadows: + - FurtherExtendedContract.x (tests/shadowing_local_variable.sol#17) (state variable) + - ExtendedContract.x (tests/shadowing_local_variable.sol#9) (state variable) + - BaseContract.x (tests/shadowing_local_variable.sol#4) (state variable) +FurtherExtendedContract.shadowingParent(uint256).y (tests/shadowing_local_variable.sol#25) shadows: + - BaseContract.y (tests/shadowing_local_variable.sol#5) (state variable) +FurtherExtendedContract.shadowingParent(uint256).z (tests/shadowing_local_variable.sol#25) shadows: + - ExtendedContract.z() (tests/shadowing_local_variable.sol#11) (function) +FurtherExtendedContract.shadowingParent(uint256).w (tests/shadowing_local_variable.sol#25) shadows: + - FurtherExtendedContract.w() (tests/shadowing_local_variable.sol#20-23) (modifier) +FurtherExtendedContract.shadowingParent(uint256).v (tests/shadowing_local_variable.sol#25) shadows: + - ExtendedContractv() (tests/shadowing_local_variable.sol#13) (event) Reference: https://github.com/crytic/slither/wiki/Detector-Documentation#local-variable-shadowing -INFO:Slither:tests/shadowing_local_variable.sol analyzed (3 contracts), 5 result(s) found +tests/shadowing_local_variable.sol analyzed (3 contracts with 1 detectors), 5 result(s) found diff --git a/tests/expected_json/shadowing_state_variable.shadowing-state.json b/tests/expected_json/shadowing_state_variable.shadowing-state.json index 2833ee769..2fa620ae0 100644 --- a/tests/expected_json/shadowing_state_variable.shadowing-state.json +++ b/tests/expected_json/shadowing_state_variable.shadowing-state.json @@ -4,10 +4,6 @@ "results": { "detectors": [ { - "check": "shadowing-state", - "impact": "High", - "confidence": "High", - "description": "DerivedContract.owner (tests/shadowing_state_variable.sol#12) shadows:\n\t- BaseContract.owner (tests/shadowing_state_variable.sol#2)\n", "elements": [ { "type": "variable", @@ -103,7 +99,12 @@ } } } - ] + ], + "description": "DerivedContract.owner (tests/shadowing_state_variable.sol#12) shadows:\n\t- BaseContract.owner (tests/shadowing_state_variable.sol#2)\n", + "markdown": "[DerivedContract.owner](tests/shadowing_state_variable.sol#L12) shadows:\n\t- [BaseContract.owner](tests/shadowing_state_variable.sol#L2)\n", + "check": "shadowing-state", + "impact": "High", + "confidence": "High" } ] } diff --git a/tests/expected_json/shadowing_state_variable.shadowing-state.txt b/tests/expected_json/shadowing_state_variable.shadowing-state.txt index 965837378..5109991c2 100644 --- a/tests/expected_json/shadowing_state_variable.shadowing-state.txt +++ b/tests/expected_json/shadowing_state_variable.shadowing-state.txt @@ -1,5 +1,5 @@ -INFO:Detectors: + DerivedContract.owner (tests/shadowing_state_variable.sol#12) shadows: - BaseContract.owner (tests/shadowing_state_variable.sol#2) Reference: https://github.com/crytic/slither/wiki/Detector-Documentation#state-variable-shadowing -INFO:Slither:tests/shadowing_state_variable.sol analyzed (2 contracts), 1 result(s) found +tests/shadowing_state_variable.sol analyzed (2 contracts with 1 detectors), 1 result(s) found diff --git a/tests/expected_json/solc_version_incorrect.solc-version.json b/tests/expected_json/solc_version_incorrect.solc-version.json index eb0c2f514..af9d454de 100644 --- a/tests/expected_json/solc_version_incorrect.solc-version.json +++ b/tests/expected_json/solc_version_incorrect.solc-version.json @@ -4,10 +4,6 @@ "results": { "detectors": [ { - "check": "solc-version", - "impact": "Informational", - "confidence": "High", - "description": "Pragma version \"^0.4.23\" allows old versions (tests/solc_version_incorrect.sol#2)\n", "elements": [ { "type": "pragma", @@ -35,13 +31,14 @@ ] } } - ] - }, - { + ], + "description": "Pragma version^0.4.23 (tests/solc_version_incorrect.sol#2) allows old versions\n", + "markdown": "Pragma version[^0.4.23](tests/solc_version_incorrect.sol#L2) allows old versions\n", "check": "solc-version", "impact": "Informational", - "confidence": "High", - "description": "Pragma version \">=0.4.0<0.6.0\" allows old versions (tests/solc_version_incorrect.sol#3)\n", + "confidence": "High" + }, + { "elements": [ { "type": "pragma", @@ -72,7 +69,12 @@ ] } } - ] + ], + "description": "Pragma version>=0.4.0<0.6.0 (tests/solc_version_incorrect.sol#3) allows old versions\n", + "markdown": "Pragma version[>=0.4.0<0.6.0](tests/solc_version_incorrect.sol#L3) allows old versions\n", + "check": "solc-version", + "impact": "Informational", + "confidence": "High" } ] } diff --git a/tests/expected_json/solc_version_incorrect.solc-version.txt b/tests/expected_json/solc_version_incorrect.solc-version.txt index 60a0c9707..d9432c890 100644 --- a/tests/expected_json/solc_version_incorrect.solc-version.txt +++ b/tests/expected_json/solc_version_incorrect.solc-version.txt @@ -1,5 +1,5 @@ -INFO:Detectors: -Pragma version "^0.4.23" allows old versions (tests/solc_version_incorrect.sol#2) -Pragma version ">=0.4.0<0.6.0" allows old versions (tests/solc_version_incorrect.sol#3) + +Pragma version^0.4.23 (tests/solc_version_incorrect.sol#2) allows old versions +Pragma version>=0.4.0<0.6.0 (tests/solc_version_incorrect.sol#3) allows old versions Reference: https://github.com/crytic/slither/wiki/Detector-Documentation#incorrect-versions-of-solidity -INFO:Slither:tests/solc_version_incorrect.sol analyzed (1 contracts), 2 result(s) found +tests/solc_version_incorrect.sol analyzed (1 contracts with 1 detectors), 2 result(s) found diff --git a/tests/expected_json/solc_version_incorrect_05.ast.json.solc-version.json b/tests/expected_json/solc_version_incorrect_05.ast.json.solc-version.json index 00b47a15a..a199ac228 100644 --- a/tests/expected_json/solc_version_incorrect_05.ast.json.solc-version.json +++ b/tests/expected_json/solc_version_incorrect_05.ast.json.solc-version.json @@ -4,10 +4,6 @@ "results": { "detectors": [ { - "check": "solc-version", - "impact": "Informational", - "confidence": "High", - "description": "Pragma version \"^0.5.5\" is known to contain severe issue (https://solidity.readthedocs.io/en/v0.5.8/bugs.html) (None)\n", "elements": [ { "type": "pragma", @@ -33,13 +29,14 @@ ] } } - ] - }, - { + ], + "description": "Pragma version^0.5.5 (None) is known to contain severe issue (https://solidity.readthedocs.io/en/v0.5.8/bugs.html)\n", + "markdown": "Pragma version[^0.5.5](None) is known to contain severe issue (https://solidity.readthedocs.io/en/v0.5.8/bugs.html)\n", "check": "solc-version", "impact": "Informational", - "confidence": "High", - "description": "Pragma version \"0.5.7\" necessitates versions too recent to be trusted. Consider deploying with 0.5.3 (None)\n", + "confidence": "High" + }, + { "elements": [ { "type": "pragma", @@ -64,7 +61,12 @@ ] } } - ] + ], + "description": "Pragma version0.5.7 (None) necessitates versions too recent to be trusted. Consider deploying with 0.5.3\n", + "markdown": "Pragma version[0.5.7](None) necessitates versions too recent to be trusted. Consider deploying with 0.5.3\n", + "check": "solc-version", + "impact": "Informational", + "confidence": "High" } ] } diff --git a/tests/expected_json/solc_version_incorrect_05.ast.json.solc-version.txt b/tests/expected_json/solc_version_incorrect_05.ast.json.solc-version.txt index 6673c1a56..0e09462e6 100644 --- a/tests/expected_json/solc_version_incorrect_05.ast.json.solc-version.txt +++ b/tests/expected_json/solc_version_incorrect_05.ast.json.solc-version.txt @@ -1,5 +1,5 @@ -INFO:Detectors: -Pragma version "^0.5.5" is known to contain severe issue (https://solidity.readthedocs.io/en/v0.5.8/bugs.html) (None) -Pragma version "0.5.7" necessitates versions too recent to be trusted. Consider deploying with 0.5.3 (None) + +Pragma version^0.5.5 (None) is known to contain severe issue (https://solidity.readthedocs.io/en/v0.5.8/bugs.html) +Pragma version0.5.7 (None) necessitates versions too recent to be trusted. Consider deploying with 0.5.3 Reference: https://github.com/crytic/slither/wiki/Detector-Documentation#incorrect-versions-of-solidity -INFO:Slither:tests/solc_version_incorrect_05.ast.json analyzed (1 contracts), 2 result(s) found +tests/solc_version_incorrect_05.ast.json analyzed (1 contracts with 1 detectors), 2 result(s) found diff --git a/tests/expected_json/timestamp.timestamp.json b/tests/expected_json/timestamp.timestamp.json index f35e6f173..1819fe638 100644 --- a/tests/expected_json/timestamp.timestamp.json +++ b/tests/expected_json/timestamp.timestamp.json @@ -4,10 +4,6 @@ "results": { "detectors": [ { - "check": "timestamp", - "impact": "Low", - "confidence": "Medium", - "description": "Timestamp.bad0() (tests/timestamp.sol#4-6) uses timestamp for comparisons\n\tDangerous comparisons:\n\t- require(bool)(block.timestamp == 0) (tests/timestamp.sol#5)\n", "elements": [ { "type": "function", @@ -149,13 +145,14 @@ } } } - ] - }, - { + ], + "description": "Timestamp.bad0() (tests/timestamp.sol#4-6) uses timestamp for comparisons\n\tDangerous comparisons:\n\t- require(bool)(block.timestamp == 0) (tests/timestamp.sol#5)\n", + "markdown": "[Timestamp.bad0()](tests/timestamp.sol#L4-L6) uses timestamp for comparisons\n\tDangerous comparisons:\n\t- [require(bool)(block.timestamp == 0)](tests/timestamp.sol#L5)\n", "check": "timestamp", "impact": "Low", - "confidence": "Medium", - "description": "Timestamp.bad1() (tests/timestamp.sol#8-11) uses timestamp for comparisons\n\tDangerous comparisons:\n\t- require(bool)(time == 0) (tests/timestamp.sol#10)\n", + "confidence": "Medium" + }, + { "elements": [ { "type": "function", @@ -299,13 +296,14 @@ } } } - ] - }, - { + ], + "description": "Timestamp.bad1() (tests/timestamp.sol#8-11) uses timestamp for comparisons\n\tDangerous comparisons:\n\t- require(bool)(time == 0) (tests/timestamp.sol#10)\n", + "markdown": "[Timestamp.bad1()](tests/timestamp.sol#L8-L11) uses timestamp for comparisons\n\tDangerous comparisons:\n\t- [require(bool)(time == 0)](tests/timestamp.sol#L10)\n", "check": "timestamp", "impact": "Low", - "confidence": "Medium", - "description": "Timestamp.bad2() (tests/timestamp.sol#13-15) uses timestamp for comparisons\n\tDangerous comparisons:\n\t- block.timestamp > 0 (tests/timestamp.sol#14)\n", + "confidence": "Medium" + }, + { "elements": [ { "type": "function", @@ -447,7 +445,12 @@ } } } - ] + ], + "description": "Timestamp.bad2() (tests/timestamp.sol#13-15) uses timestamp for comparisons\n\tDangerous comparisons:\n\t- block.timestamp > 0 (tests/timestamp.sol#14)\n", + "markdown": "[Timestamp.bad2()](tests/timestamp.sol#L13-L15) uses timestamp for comparisons\n\tDangerous comparisons:\n\t- [block.timestamp > 0](tests/timestamp.sol#L14)\n", + "check": "timestamp", + "impact": "Low", + "confidence": "Medium" } ] } diff --git a/tests/expected_json/timestamp.timestamp.txt b/tests/expected_json/timestamp.timestamp.txt index ef64d694e..f26348c0c 100644 --- a/tests/expected_json/timestamp.timestamp.txt +++ b/tests/expected_json/timestamp.timestamp.txt @@ -1,4 +1,4 @@ -INFO:Detectors: + Timestamp.bad0() (tests/timestamp.sol#4-6) uses timestamp for comparisons Dangerous comparisons: - require(bool)(block.timestamp == 0) (tests/timestamp.sol#5) @@ -9,4 +9,4 @@ Timestamp.bad2() (tests/timestamp.sol#13-15) uses timestamp for comparisons Dangerous comparisons: - block.timestamp > 0 (tests/timestamp.sol#14) Reference: https://github.com/crytic/slither/wiki/Detector-Documentation#block-timestamp -INFO:Slither:tests/timestamp.sol analyzed (1 contracts), 3 result(s) found +tests/timestamp.sol analyzed (1 contracts with 1 detectors), 3 result(s) found diff --git a/tests/expected_json/too_many_digits.too-many-digits.json b/tests/expected_json/too_many_digits.too-many-digits.json index 0e8cf635f..9e7a211f5 100644 --- a/tests/expected_json/too_many_digits.too-many-digits.json +++ b/tests/expected_json/too_many_digits.too-many-digits.json @@ -4,11 +4,89 @@ "results": { "detectors": [ { - "check": "too-many-digits", - "impact": "Informational", - "confidence": "Medium", - "description": "C.f (tests/too_many_digits.sol#9-15) uses literals with too many digits:\n\t- x1 = 0x000001\n", "elements": [ + { + "type": "function", + "name": "f", + "source_mapping": { + "start": 174, + "length": 195, + "filename_used": "/home/travis/build/crytic/slither/tests/too_many_digits.sol", + "filename_relative": "tests/too_many_digits.sol", + "filename_absolute": "/home/travis/build/crytic/slither/tests/too_many_digits.sol", + "filename_short": "tests/too_many_digits.sol", + "is_dependency": false, + "lines": [ + 9, + 10, + 11, + 12, + 13, + 14, + 15 + ], + "starting_column": 5, + "ending_column": 6 + }, + "type_specific_fields": { + "parent": { + "type": "contract", + "name": "C", + "source_mapping": { + "start": 25, + "length": 897, + "filename_used": "/home/travis/build/crytic/slither/tests/too_many_digits.sol", + "filename_relative": "tests/too_many_digits.sol", + "filename_absolute": "/home/travis/build/crytic/slither/tests/too_many_digits.sol", + "filename_short": "tests/too_many_digits.sol", + "is_dependency": false, + "lines": [ + 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 + ], + "starting_column": 1, + "ending_column": 2 + } + }, + "signature": "f()" + } + }, { "type": "node", "name": "x1 = 0x000001", @@ -111,14 +189,97 @@ } } } - ] - }, - { + ], + "description": "C.f() (tests/too_many_digits.sol#9-15) uses literals with too many digits:\n\t- x1 = 0x000001 (tests/too_many_digits.sol#10)\n", + "markdown": "[C.f()](tests/too_many_digits.sol#L9-L15) uses literals with too many digits:\n\t- [x1 = 0x000001](tests/too_many_digits.sol#L10)\n", "check": "too-many-digits", "impact": "Informational", - "confidence": "Medium", - "description": "C.f (tests/too_many_digits.sol#9-15) uses literals with too many digits:\n\t- x2 = 0x0000000000001\n", + "confidence": "Medium" + }, + { "elements": [ + { + "type": "function", + "name": "f", + "source_mapping": { + "start": 174, + "length": 195, + "filename_used": "/home/travis/build/crytic/slither/tests/too_many_digits.sol", + "filename_relative": "tests/too_many_digits.sol", + "filename_absolute": "/home/travis/build/crytic/slither/tests/too_many_digits.sol", + "filename_short": "tests/too_many_digits.sol", + "is_dependency": false, + "lines": [ + 9, + 10, + 11, + 12, + 13, + 14, + 15 + ], + "starting_column": 5, + "ending_column": 6 + }, + "type_specific_fields": { + "parent": { + "type": "contract", + "name": "C", + "source_mapping": { + "start": 25, + "length": 897, + "filename_used": "/home/travis/build/crytic/slither/tests/too_many_digits.sol", + "filename_relative": "tests/too_many_digits.sol", + "filename_absolute": "/home/travis/build/crytic/slither/tests/too_many_digits.sol", + "filename_short": "tests/too_many_digits.sol", + "is_dependency": false, + "lines": [ + 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 + ], + "starting_column": 1, + "ending_column": 2 + } + }, + "signature": "f()" + } + }, { "type": "node", "name": "x2 = 0x0000000000001", @@ -221,14 +382,97 @@ } } } - ] - }, - { + ], + "description": "C.f() (tests/too_many_digits.sol#9-15) uses literals with too many digits:\n\t- x2 = 0x0000000000001 (tests/too_many_digits.sol#11)\n", + "markdown": "[C.f()](tests/too_many_digits.sol#L9-L15) uses literals with too many digits:\n\t- [x2 = 0x0000000000001](tests/too_many_digits.sol#L11)\n", "check": "too-many-digits", "impact": "Informational", - "confidence": "Medium", - "description": "C.f (tests/too_many_digits.sol#9-15) uses literals with too many digits:\n\t- x3 = 1000000000000000000\n", + "confidence": "Medium" + }, + { "elements": [ + { + "type": "function", + "name": "f", + "source_mapping": { + "start": 174, + "length": 195, + "filename_used": "/home/travis/build/crytic/slither/tests/too_many_digits.sol", + "filename_relative": "tests/too_many_digits.sol", + "filename_absolute": "/home/travis/build/crytic/slither/tests/too_many_digits.sol", + "filename_short": "tests/too_many_digits.sol", + "is_dependency": false, + "lines": [ + 9, + 10, + 11, + 12, + 13, + 14, + 15 + ], + "starting_column": 5, + "ending_column": 6 + }, + "type_specific_fields": { + "parent": { + "type": "contract", + "name": "C", + "source_mapping": { + "start": 25, + "length": 897, + "filename_used": "/home/travis/build/crytic/slither/tests/too_many_digits.sol", + "filename_relative": "tests/too_many_digits.sol", + "filename_absolute": "/home/travis/build/crytic/slither/tests/too_many_digits.sol", + "filename_short": "tests/too_many_digits.sol", + "is_dependency": false, + "lines": [ + 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 + ], + "starting_column": 1, + "ending_column": 2 + } + }, + "signature": "f()" + } + }, { "type": "node", "name": "x3 = 1000000000000000000", @@ -331,14 +575,97 @@ } } } - ] - }, - { + ], + "description": "C.f() (tests/too_many_digits.sol#9-15) uses literals with too many digits:\n\t- x3 = 1000000000000000000 (tests/too_many_digits.sol#12)\n", + "markdown": "[C.f()](tests/too_many_digits.sol#L9-L15) uses literals with too many digits:\n\t- [x3 = 1000000000000000000](tests/too_many_digits.sol#L12)\n", "check": "too-many-digits", "impact": "Informational", - "confidence": "Medium", - "description": "C.f (tests/too_many_digits.sol#9-15) uses literals with too many digits:\n\t- x4 = 100000\n", + "confidence": "Medium" + }, + { "elements": [ + { + "type": "function", + "name": "f", + "source_mapping": { + "start": 174, + "length": 195, + "filename_used": "/home/travis/build/crytic/slither/tests/too_many_digits.sol", + "filename_relative": "tests/too_many_digits.sol", + "filename_absolute": "/home/travis/build/crytic/slither/tests/too_many_digits.sol", + "filename_short": "tests/too_many_digits.sol", + "is_dependency": false, + "lines": [ + 9, + 10, + 11, + 12, + 13, + 14, + 15 + ], + "starting_column": 5, + "ending_column": 6 + }, + "type_specific_fields": { + "parent": { + "type": "contract", + "name": "C", + "source_mapping": { + "start": 25, + "length": 897, + "filename_used": "/home/travis/build/crytic/slither/tests/too_many_digits.sol", + "filename_relative": "tests/too_many_digits.sol", + "filename_absolute": "/home/travis/build/crytic/slither/tests/too_many_digits.sol", + "filename_short": "tests/too_many_digits.sol", + "is_dependency": false, + "lines": [ + 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 + ], + "starting_column": 1, + "ending_column": 2 + } + }, + "signature": "f()" + } + }, { "type": "node", "name": "x4 = 100000", @@ -441,14 +768,95 @@ } } } - ] - }, - { + ], + "description": "C.f() (tests/too_many_digits.sol#9-15) uses literals with too many digits:\n\t- x4 = 100000 (tests/too_many_digits.sol#13)\n", + "markdown": "[C.f()](tests/too_many_digits.sol#L9-L15) uses literals with too many digits:\n\t- [x4 = 100000](tests/too_many_digits.sol#L13)\n", "check": "too-many-digits", "impact": "Informational", - "confidence": "Medium", - "description": "C.h (tests/too_many_digits.sol#20-24) uses literals with too many digits:\n\t- x2 = 100000\n", + "confidence": "Medium" + }, + { "elements": [ + { + "type": "function", + "name": "h", + "source_mapping": { + "start": 453, + "length": 113, + "filename_used": "/home/travis/build/crytic/slither/tests/too_many_digits.sol", + "filename_relative": "tests/too_many_digits.sol", + "filename_absolute": "/home/travis/build/crytic/slither/tests/too_many_digits.sol", + "filename_short": "tests/too_many_digits.sol", + "is_dependency": false, + "lines": [ + 20, + 21, + 22, + 23, + 24 + ], + "starting_column": 5, + "ending_column": 6 + }, + "type_specific_fields": { + "parent": { + "type": "contract", + "name": "C", + "source_mapping": { + "start": 25, + "length": 897, + "filename_used": "/home/travis/build/crytic/slither/tests/too_many_digits.sol", + "filename_relative": "tests/too_many_digits.sol", + "filename_absolute": "/home/travis/build/crytic/slither/tests/too_many_digits.sol", + "filename_short": "tests/too_many_digits.sol", + "is_dependency": false, + "lines": [ + 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 + ], + "starting_column": 1, + "ending_column": 2 + } + }, + "signature": "h()" + } + }, { "type": "node", "name": "x2 = 100000", @@ -549,7 +957,12 @@ } } } - ] + ], + "description": "C.h() (tests/too_many_digits.sol#20-24) uses literals with too many digits:\n\t- x2 = 100000 (tests/too_many_digits.sol#22)\n", + "markdown": "[C.h()](tests/too_many_digits.sol#L20-L24) uses literals with too many digits:\n\t- [x2 = 100000](tests/too_many_digits.sol#L22)\n", + "check": "too-many-digits", + "impact": "Informational", + "confidence": "Medium" } ] } diff --git a/tests/expected_json/too_many_digits.too-many-digits.txt b/tests/expected_json/too_many_digits.too-many-digits.txt index 4e5ecbaa1..621ba8e85 100644 --- a/tests/expected_json/too_many_digits.too-many-digits.txt +++ b/tests/expected_json/too_many_digits.too-many-digits.txt @@ -1,13 +1,13 @@  -C.f (tests/too_many_digits.sol#9-15) uses literals with too many digits: - - x1 = 0x000001 -C.f (tests/too_many_digits.sol#9-15) uses literals with too many digits: - - x2 = 0x0000000000001 -C.f (tests/too_many_digits.sol#9-15) uses literals with too many digits: - - x3 = 1000000000000000000 -C.f (tests/too_many_digits.sol#9-15) uses literals with too many digits: - - x4 = 100000 -C.h (tests/too_many_digits.sol#20-24) uses literals with too many digits: - - x2 = 100000 +C.f() (tests/too_many_digits.sol#9-15) uses literals with too many digits: + - x1 = 0x000001 (tests/too_many_digits.sol#10) +C.f() (tests/too_many_digits.sol#9-15) uses literals with too many digits: + - x2 = 0x0000000000001 (tests/too_many_digits.sol#11) +C.f() (tests/too_many_digits.sol#9-15) uses literals with too many digits: + - x3 = 1000000000000000000 (tests/too_many_digits.sol#12) +C.f() (tests/too_many_digits.sol#9-15) uses literals with too many digits: + - x4 = 100000 (tests/too_many_digits.sol#13) +C.h() (tests/too_many_digits.sol#20-24) uses literals with too many digits: + - x2 = 100000 (tests/too_many_digits.sol#22) Reference: https://github.com/crytic/slither/wiki/Detector-Documentation#too-many-digits -tests/too_many_digits.sol analyzed (1 contracts), 5 result(s) found +tests/too_many_digits.sol analyzed (1 contracts with 1 detectors), 5 result(s) found diff --git a/tests/expected_json/tx_origin-0.5.1.tx-origin.json b/tests/expected_json/tx_origin-0.5.1.tx-origin.json index 020e85f5e..c0efe7dd0 100644 --- a/tests/expected_json/tx_origin-0.5.1.tx-origin.json +++ b/tests/expected_json/tx_origin-0.5.1.tx-origin.json @@ -4,11 +4,71 @@ "results": { "detectors": [ { - "check": "tx-origin", - "impact": "Medium", - "confidence": "Medium", - "description": "TxOrigin.bug0() uses tx.origin for authorization: \"require(bool)(tx.origin == owner)\" (tests/tx_origin-0.5.1.sol#10)\n", "elements": [ + { + "type": "function", + "name": "bug0", + "source_mapping": { + "start": 127, + "length": 66, + "filename_used": "/home/travis/build/crytic/slither/tests/tx_origin-0.5.1.sol", + "filename_relative": "tests/tx_origin-0.5.1.sol", + "filename_absolute": "/home/travis/build/crytic/slither/tests/tx_origin-0.5.1.sol", + "filename_short": "tests/tx_origin-0.5.1.sol", + "is_dependency": false, + "lines": [ + 9, + 10, + 11 + ], + "starting_column": 5, + "ending_column": 6 + }, + "type_specific_fields": { + "parent": { + "type": "contract", + "name": "TxOrigin", + "source_mapping": { + "start": 25, + "length": 442, + "filename_used": "/home/travis/build/crytic/slither/tests/tx_origin-0.5.1.sol", + "filename_relative": "tests/tx_origin-0.5.1.sol", + "filename_absolute": "/home/travis/build/crytic/slither/tests/tx_origin-0.5.1.sol", + "filename_short": "tests/tx_origin-0.5.1.sol", + "is_dependency": false, + "lines": [ + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26 + ], + "starting_column": 1, + "ending_column": 2 + } + }, + "signature": "bug0()" + } + }, { "type": "node", "name": "require(bool)(tx.origin == owner)", @@ -93,14 +153,81 @@ } } } - ] - }, - { + ], + "description": "TxOrigin.bug0() (tests/tx_origin-0.5.1.sol#9-11) uses tx.origin for authorization: require(bool)(tx.origin == owner) (tests/tx_origin-0.5.1.sol#10)\n", + "markdown": "[TxOrigin.bug0()](tests/tx_origin-0.5.1.sol#L9-L11) uses tx.origin for authorization: [require(bool)(tx.origin == owner)](tests/tx_origin-0.5.1.sol#L10)\n", "check": "tx-origin", "impact": "Medium", - "confidence": "Medium", - "description": "TxOrigin.bug2() uses tx.origin for authorization: \"tx.origin != owner\" (tests/tx_origin-0.5.1.sol#14)\n", + "confidence": "Medium" + }, + { "elements": [ + { + "type": "function", + "name": "bug2", + "source_mapping": { + "start": 199, + "length": 95, + "filename_used": "/home/travis/build/crytic/slither/tests/tx_origin-0.5.1.sol", + "filename_relative": "tests/tx_origin-0.5.1.sol", + "filename_absolute": "/home/travis/build/crytic/slither/tests/tx_origin-0.5.1.sol", + "filename_short": "tests/tx_origin-0.5.1.sol", + "is_dependency": false, + "lines": [ + 13, + 14, + 15, + 16, + 17 + ], + "starting_column": 5, + "ending_column": 6 + }, + "type_specific_fields": { + "parent": { + "type": "contract", + "name": "TxOrigin", + "source_mapping": { + "start": 25, + "length": 442, + "filename_used": "/home/travis/build/crytic/slither/tests/tx_origin-0.5.1.sol", + "filename_relative": "tests/tx_origin-0.5.1.sol", + "filename_absolute": "/home/travis/build/crytic/slither/tests/tx_origin-0.5.1.sol", + "filename_short": "tests/tx_origin-0.5.1.sol", + "is_dependency": false, + "lines": [ + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26 + ], + "starting_column": 1, + "ending_column": 2 + } + }, + "signature": "bug2()" + } + }, { "type": "node", "name": "tx.origin != owner", @@ -187,7 +314,12 @@ } } } - ] + ], + "description": "TxOrigin.bug2() (tests/tx_origin-0.5.1.sol#13-17) uses tx.origin for authorization: tx.origin != owner (tests/tx_origin-0.5.1.sol#14)\n", + "markdown": "[TxOrigin.bug2()](tests/tx_origin-0.5.1.sol#L13-L17) uses tx.origin for authorization: [tx.origin != owner](tests/tx_origin-0.5.1.sol#L14)\n", + "check": "tx-origin", + "impact": "Medium", + "confidence": "Medium" } ] } diff --git a/tests/expected_json/tx_origin-0.5.1.tx-origin.txt b/tests/expected_json/tx_origin-0.5.1.tx-origin.txt index 24811f6e4..e5e11d02f 100644 --- a/tests/expected_json/tx_origin-0.5.1.tx-origin.txt +++ b/tests/expected_json/tx_origin-0.5.1.tx-origin.txt @@ -1,5 +1,5 @@ -INFO:Detectors: -TxOrigin.bug0() uses tx.origin for authorization: "require(bool)(tx.origin == owner)" (tests/tx_origin-0.5.1.sol#10) -TxOrigin.bug2() uses tx.origin for authorization: "tx.origin != owner" (tests/tx_origin-0.5.1.sol#14) + +TxOrigin.bug0() (tests/tx_origin-0.5.1.sol#9-11) uses tx.origin for authorization: require(bool)(tx.origin == owner) (tests/tx_origin-0.5.1.sol#10) +TxOrigin.bug2() (tests/tx_origin-0.5.1.sol#13-17) uses tx.origin for authorization: tx.origin != owner (tests/tx_origin-0.5.1.sol#14) Reference: https://github.com/crytic/slither/wiki/Detector-Documentation#dangerous-usage-of-txorigin -INFO:Slither:tests/tx_origin-0.5.1.sol analyzed (1 contracts), 2 result(s) found +tests/tx_origin-0.5.1.sol analyzed (1 contracts with 1 detectors), 2 result(s) found diff --git a/tests/expected_json/tx_origin.tx-origin.json b/tests/expected_json/tx_origin.tx-origin.json index baa703378..23f4673f4 100644 --- a/tests/expected_json/tx_origin.tx-origin.json +++ b/tests/expected_json/tx_origin.tx-origin.json @@ -4,11 +4,71 @@ "results": { "detectors": [ { - "check": "tx-origin", - "impact": "Medium", - "confidence": "Medium", - "description": "TxOrigin.bug0() uses tx.origin for authorization: \"require(bool)(tx.origin == owner)\" (tests/tx_origin.sol#10)\n", "elements": [ + { + "type": "function", + "name": "bug0", + "source_mapping": { + "start": 116, + "length": 60, + "filename_used": "/home/travis/build/crytic/slither/tests/tx_origin.sol", + "filename_relative": "tests/tx_origin.sol", + "filename_absolute": "/home/travis/build/crytic/slither/tests/tx_origin.sol", + "filename_short": "tests/tx_origin.sol", + "is_dependency": false, + "lines": [ + 9, + 10, + 11 + ], + "starting_column": 5, + "ending_column": 6 + }, + "type_specific_fields": { + "parent": { + "type": "contract", + "name": "TxOrigin", + "source_mapping": { + "start": 28, + "length": 393, + "filename_used": "/home/travis/build/crytic/slither/tests/tx_origin.sol", + "filename_relative": "tests/tx_origin.sol", + "filename_absolute": "/home/travis/build/crytic/slither/tests/tx_origin.sol", + "filename_short": "tests/tx_origin.sol", + "is_dependency": false, + "lines": [ + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26 + ], + "starting_column": 1, + "ending_column": 2 + } + }, + "signature": "bug0()" + } + }, { "type": "node", "name": "require(bool)(tx.origin == owner)", @@ -93,14 +153,81 @@ } } } - ] - }, - { + ], + "description": "TxOrigin.bug0() (tests/tx_origin.sol#9-11) uses tx.origin for authorization: require(bool)(tx.origin == owner) (tests/tx_origin.sol#10)\n", + "markdown": "[TxOrigin.bug0()](tests/tx_origin.sol#L9-L11) uses tx.origin for authorization: [require(bool)(tx.origin == owner)](tests/tx_origin.sol#L10)\n", "check": "tx-origin", "impact": "Medium", - "confidence": "Medium", - "description": "TxOrigin.bug2() uses tx.origin for authorization: \"tx.origin != owner\" (tests/tx_origin.sol#14)\n", + "confidence": "Medium" + }, + { "elements": [ + { + "type": "function", + "name": "bug2", + "source_mapping": { + "start": 182, + "length": 89, + "filename_used": "/home/travis/build/crytic/slither/tests/tx_origin.sol", + "filename_relative": "tests/tx_origin.sol", + "filename_absolute": "/home/travis/build/crytic/slither/tests/tx_origin.sol", + "filename_short": "tests/tx_origin.sol", + "is_dependency": false, + "lines": [ + 13, + 14, + 15, + 16, + 17 + ], + "starting_column": 5, + "ending_column": 6 + }, + "type_specific_fields": { + "parent": { + "type": "contract", + "name": "TxOrigin", + "source_mapping": { + "start": 28, + "length": 393, + "filename_used": "/home/travis/build/crytic/slither/tests/tx_origin.sol", + "filename_relative": "tests/tx_origin.sol", + "filename_absolute": "/home/travis/build/crytic/slither/tests/tx_origin.sol", + "filename_short": "tests/tx_origin.sol", + "is_dependency": false, + "lines": [ + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26 + ], + "starting_column": 1, + "ending_column": 2 + } + }, + "signature": "bug2()" + } + }, { "type": "node", "name": "tx.origin != owner", @@ -187,7 +314,12 @@ } } } - ] + ], + "description": "TxOrigin.bug2() (tests/tx_origin.sol#13-17) uses tx.origin for authorization: tx.origin != owner (tests/tx_origin.sol#14)\n", + "markdown": "[TxOrigin.bug2()](tests/tx_origin.sol#L13-L17) uses tx.origin for authorization: [tx.origin != owner](tests/tx_origin.sol#L14)\n", + "check": "tx-origin", + "impact": "Medium", + "confidence": "Medium" } ] } diff --git a/tests/expected_json/tx_origin.tx-origin.txt b/tests/expected_json/tx_origin.tx-origin.txt index ad8f9b78a..c9f9fbc92 100644 --- a/tests/expected_json/tx_origin.tx-origin.txt +++ b/tests/expected_json/tx_origin.tx-origin.txt @@ -1,5 +1,5 @@ -INFO:Detectors: -TxOrigin.bug0() uses tx.origin for authorization: "require(bool)(tx.origin == owner)" (tests/tx_origin.sol#10) -TxOrigin.bug2() uses tx.origin for authorization: "tx.origin != owner" (tests/tx_origin.sol#14) + +TxOrigin.bug0() (tests/tx_origin.sol#9-11) uses tx.origin for authorization: require(bool)(tx.origin == owner) (tests/tx_origin.sol#10) +TxOrigin.bug2() (tests/tx_origin.sol#13-17) uses tx.origin for authorization: tx.origin != owner (tests/tx_origin.sol#14) Reference: https://github.com/crytic/slither/wiki/Detector-Documentation#dangerous-usage-of-txorigin -INFO:Slither:tests/tx_origin.sol analyzed (1 contracts), 2 result(s) found +tests/tx_origin.sol analyzed (1 contracts with 1 detectors), 2 result(s) found diff --git a/tests/expected_json/unchecked_lowlevel-0.5.1.unchecked-lowlevel.json b/tests/expected_json/unchecked_lowlevel-0.5.1.unchecked-lowlevel.json index 3548d3215..19197cda8 100644 --- a/tests/expected_json/unchecked_lowlevel-0.5.1.unchecked-lowlevel.json +++ b/tests/expected_json/unchecked_lowlevel-0.5.1.unchecked-lowlevel.json @@ -4,11 +4,58 @@ "results": { "detectors": [ { - "check": "unchecked-lowlevel", - "impact": "Medium", - "confidence": "Medium", - "description": "MyConc.bad(address) (tests/unchecked_lowlevel-0.5.1.sol#2-4) ignores return value by low-level calls \"dst.call.value(msg.value)()\" (tests/unchecked_lowlevel-0.5.1.sol#3)\n", "elements": [ + { + "type": "function", + "name": "bad", + "source_mapping": { + "start": 21, + "length": 96, + "filename_used": "/home/travis/build/crytic/slither/tests/unchecked_lowlevel-0.5.1.sol", + "filename_relative": "tests/unchecked_lowlevel-0.5.1.sol", + "filename_absolute": "/home/travis/build/crytic/slither/tests/unchecked_lowlevel-0.5.1.sol", + "filename_short": "tests/unchecked_lowlevel-0.5.1.sol", + "is_dependency": false, + "lines": [ + 2, + 3, + 4 + ], + "starting_column": 5, + "ending_column": 6 + }, + "type_specific_fields": { + "parent": { + "type": "contract", + "name": "MyConc", + "source_mapping": { + "start": 0, + "length": 274, + "filename_used": "/home/travis/build/crytic/slither/tests/unchecked_lowlevel-0.5.1.sol", + "filename_relative": "tests/unchecked_lowlevel-0.5.1.sol", + "filename_absolute": "/home/travis/build/crytic/slither/tests/unchecked_lowlevel-0.5.1.sol", + "filename_short": "tests/unchecked_lowlevel-0.5.1.sol", + "is_dependency": false, + "lines": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11 + ], + "starting_column": 1, + "ending_column": 2 + } + }, + "signature": "bad(address)" + } + }, { "type": "node", "name": "dst.call.value(msg.value)()", @@ -79,59 +126,13 @@ } } } - }, - { - "type": "function", - "name": "bad", - "source_mapping": { - "start": 21, - "length": 96, - "filename_used": "/home/travis/build/crytic/slither/tests/unchecked_lowlevel-0.5.1.sol", - "filename_relative": "tests/unchecked_lowlevel-0.5.1.sol", - "filename_absolute": "/home/travis/build/crytic/slither/tests/unchecked_lowlevel-0.5.1.sol", - "filename_short": "tests/unchecked_lowlevel-0.5.1.sol", - "is_dependency": false, - "lines": [ - 2, - 3, - 4 - ], - "starting_column": 5, - "ending_column": 6 - }, - "type_specific_fields": { - "parent": { - "type": "contract", - "name": "MyConc", - "source_mapping": { - "start": 0, - "length": 274, - "filename_used": "/home/travis/build/crytic/slither/tests/unchecked_lowlevel-0.5.1.sol", - "filename_relative": "tests/unchecked_lowlevel-0.5.1.sol", - "filename_absolute": "/home/travis/build/crytic/slither/tests/unchecked_lowlevel-0.5.1.sol", - "filename_short": "tests/unchecked_lowlevel-0.5.1.sol", - "is_dependency": false, - "lines": [ - 1, - 2, - 3, - 4, - 5, - 6, - 7, - 8, - 9, - 10, - 11 - ], - "starting_column": 1, - "ending_column": 2 - } - }, - "signature": "bad(address)" - } } - ] + ], + "description": "MyConc.bad(address) (tests/unchecked_lowlevel-0.5.1.sol#2-4) ignores return value by dst.call.value(msg.value)() (tests/unchecked_lowlevel-0.5.1.sol#3)\n", + "markdown": "[MyConc.bad(address)](tests/unchecked_lowlevel-0.5.1.sol#L2-L4) ignores return value by [dst.call.value(msg.value)()](tests/unchecked_lowlevel-0.5.1.sol#L3)\n", + "check": "unchecked-lowlevel", + "impact": "Medium", + "confidence": "Medium" } ] } diff --git a/tests/expected_json/unchecked_lowlevel-0.5.1.unchecked-lowlevel.txt b/tests/expected_json/unchecked_lowlevel-0.5.1.unchecked-lowlevel.txt index 42dbda5b4..59a0478e0 100644 --- a/tests/expected_json/unchecked_lowlevel-0.5.1.unchecked-lowlevel.txt +++ b/tests/expected_json/unchecked_lowlevel-0.5.1.unchecked-lowlevel.txt @@ -1,4 +1,4 @@ -INFO:Detectors: -MyConc.bad(address) (tests/unchecked_lowlevel-0.5.1.sol#2-4) ignores return value by low-level calls "dst.call.value(msg.value)()" (tests/unchecked_lowlevel-0.5.1.sol#3) + +MyConc.bad(address) (tests/unchecked_lowlevel-0.5.1.sol#2-4) ignores return value by dst.call.value(msg.value)() (tests/unchecked_lowlevel-0.5.1.sol#3) Reference: https://github.com/crytic/slither/wiki/Detector-Documentation#unchecked-low-level-calls -INFO:Slither:tests/unchecked_lowlevel-0.5.1.sol analyzed (1 contracts), 1 result(s) found +tests/unchecked_lowlevel-0.5.1.sol analyzed (1 contracts with 1 detectors), 1 result(s) found diff --git a/tests/expected_json/unchecked_lowlevel.unchecked-lowlevel.json b/tests/expected_json/unchecked_lowlevel.unchecked-lowlevel.json index 9c964c90b..5c51078ad 100644 --- a/tests/expected_json/unchecked_lowlevel.unchecked-lowlevel.json +++ b/tests/expected_json/unchecked_lowlevel.unchecked-lowlevel.json @@ -4,11 +4,57 @@ "results": { "detectors": [ { - "check": "unchecked-lowlevel", - "impact": "Medium", - "confidence": "Medium", - "description": "MyConc.bad(address) (tests/unchecked_lowlevel.sol#2-4) ignores return value by low-level calls \"dst.call.value(msg.value)()\" (tests/unchecked_lowlevel.sol#3)\n", "elements": [ + { + "type": "function", + "name": "bad", + "source_mapping": { + "start": 21, + "length": 88, + "filename_used": "/home/travis/build/crytic/slither/tests/unchecked_lowlevel.sol", + "filename_relative": "tests/unchecked_lowlevel.sol", + "filename_absolute": "/home/travis/build/crytic/slither/tests/unchecked_lowlevel.sol", + "filename_short": "tests/unchecked_lowlevel.sol", + "is_dependency": false, + "lines": [ + 2, + 3, + 4 + ], + "starting_column": 5, + "ending_column": 6 + }, + "type_specific_fields": { + "parent": { + "type": "contract", + "name": "MyConc", + "source_mapping": { + "start": 0, + "length": 214, + "filename_used": "/home/travis/build/crytic/slither/tests/unchecked_lowlevel.sol", + "filename_relative": "tests/unchecked_lowlevel.sol", + "filename_absolute": "/home/travis/build/crytic/slither/tests/unchecked_lowlevel.sol", + "filename_short": "tests/unchecked_lowlevel.sol", + "is_dependency": false, + "lines": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10 + ], + "starting_column": 1, + "ending_column": 2 + } + }, + "signature": "bad(address)" + } + }, { "type": "node", "name": "dst.call.value(msg.value)()", @@ -78,58 +124,13 @@ } } } - }, - { - "type": "function", - "name": "bad", - "source_mapping": { - "start": 21, - "length": 88, - "filename_used": "/home/travis/build/crytic/slither/tests/unchecked_lowlevel.sol", - "filename_relative": "tests/unchecked_lowlevel.sol", - "filename_absolute": "/home/travis/build/crytic/slither/tests/unchecked_lowlevel.sol", - "filename_short": "tests/unchecked_lowlevel.sol", - "is_dependency": false, - "lines": [ - 2, - 3, - 4 - ], - "starting_column": 5, - "ending_column": 6 - }, - "type_specific_fields": { - "parent": { - "type": "contract", - "name": "MyConc", - "source_mapping": { - "start": 0, - "length": 214, - "filename_used": "/home/travis/build/crytic/slither/tests/unchecked_lowlevel.sol", - "filename_relative": "tests/unchecked_lowlevel.sol", - "filename_absolute": "/home/travis/build/crytic/slither/tests/unchecked_lowlevel.sol", - "filename_short": "tests/unchecked_lowlevel.sol", - "is_dependency": false, - "lines": [ - 1, - 2, - 3, - 4, - 5, - 6, - 7, - 8, - 9, - 10 - ], - "starting_column": 1, - "ending_column": 2 - } - }, - "signature": "bad(address)" - } } - ] + ], + "description": "MyConc.bad(address) (tests/unchecked_lowlevel.sol#2-4) ignores return value by dst.call.value(msg.value)() (tests/unchecked_lowlevel.sol#3)\n", + "markdown": "[MyConc.bad(address)](tests/unchecked_lowlevel.sol#L2-L4) ignores return value by [dst.call.value(msg.value)()](tests/unchecked_lowlevel.sol#L3)\n", + "check": "unchecked-lowlevel", + "impact": "Medium", + "confidence": "Medium" } ] } diff --git a/tests/expected_json/unchecked_lowlevel.unchecked-lowlevel.txt b/tests/expected_json/unchecked_lowlevel.unchecked-lowlevel.txt index 18ab55207..7506fb57b 100644 --- a/tests/expected_json/unchecked_lowlevel.unchecked-lowlevel.txt +++ b/tests/expected_json/unchecked_lowlevel.unchecked-lowlevel.txt @@ -1,4 +1,4 @@ -INFO:Detectors: -MyConc.bad(address) (tests/unchecked_lowlevel.sol#2-4) ignores return value by low-level calls "dst.call.value(msg.value)()" (tests/unchecked_lowlevel.sol#3) + +MyConc.bad(address) (tests/unchecked_lowlevel.sol#2-4) ignores return value by dst.call.value(msg.value)() (tests/unchecked_lowlevel.sol#3) Reference: https://github.com/crytic/slither/wiki/Detector-Documentation#unchecked-low-level-calls -INFO:Slither:tests/unchecked_lowlevel.sol analyzed (1 contracts), 1 result(s) found +tests/unchecked_lowlevel.sol analyzed (1 contracts with 1 detectors), 1 result(s) found diff --git a/tests/expected_json/unchecked_send-0.5.1.unchecked-send.json b/tests/expected_json/unchecked_send-0.5.1.unchecked-send.json index 26bf7efdd..0ac4d1e2e 100644 --- a/tests/expected_json/unchecked_send-0.5.1.unchecked-send.json +++ b/tests/expected_json/unchecked_send-0.5.1.unchecked-send.json @@ -4,11 +4,65 @@ "results": { "detectors": [ { - "check": "unchecked-send", - "impact": "Medium", - "confidence": "Medium", - "description": "MyConc.bad(address) (tests/unchecked_send-0.5.1.sol#2-4) ignores return value by send calls \"dst.send(msg.value)\" (tests/unchecked_send-0.5.1.sol#3)\n", "elements": [ + { + "type": "function", + "name": "bad", + "source_mapping": { + "start": 21, + "length": 86, + "filename_used": "/home/travis/build/crytic/slither/tests/unchecked_send-0.5.1.sol", + "filename_relative": "tests/unchecked_send-0.5.1.sol", + "filename_absolute": "/home/travis/build/crytic/slither/tests/unchecked_send-0.5.1.sol", + "filename_short": "tests/unchecked_send-0.5.1.sol", + "is_dependency": false, + "lines": [ + 2, + 3, + 4 + ], + "starting_column": 5, + "ending_column": 6 + }, + "type_specific_fields": { + "parent": { + "type": "contract", + "name": "MyConc", + "source_mapping": { + "start": 0, + "length": 419, + "filename_used": "/home/travis/build/crytic/slither/tests/unchecked_send-0.5.1.sol", + "filename_relative": "tests/unchecked_send-0.5.1.sol", + "filename_absolute": "/home/travis/build/crytic/slither/tests/unchecked_send-0.5.1.sol", + "filename_short": "tests/unchecked_send-0.5.1.sol", + "is_dependency": false, + "lines": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18 + ], + "starting_column": 1, + "ending_column": 2 + } + }, + "signature": "bad(address)" + } + }, { "type": "node", "name": "dst.send(msg.value)", @@ -86,66 +140,13 @@ } } } - }, - { - "type": "function", - "name": "bad", - "source_mapping": { - "start": 21, - "length": 86, - "filename_used": "/home/travis/build/crytic/slither/tests/unchecked_send-0.5.1.sol", - "filename_relative": "tests/unchecked_send-0.5.1.sol", - "filename_absolute": "/home/travis/build/crytic/slither/tests/unchecked_send-0.5.1.sol", - "filename_short": "tests/unchecked_send-0.5.1.sol", - "is_dependency": false, - "lines": [ - 2, - 3, - 4 - ], - "starting_column": 5, - "ending_column": 6 - }, - "type_specific_fields": { - "parent": { - "type": "contract", - "name": "MyConc", - "source_mapping": { - "start": 0, - "length": 419, - "filename_used": "/home/travis/build/crytic/slither/tests/unchecked_send-0.5.1.sol", - "filename_relative": "tests/unchecked_send-0.5.1.sol", - "filename_absolute": "/home/travis/build/crytic/slither/tests/unchecked_send-0.5.1.sol", - "filename_short": "tests/unchecked_send-0.5.1.sol", - "is_dependency": false, - "lines": [ - 1, - 2, - 3, - 4, - 5, - 6, - 7, - 8, - 9, - 10, - 11, - 12, - 13, - 14, - 15, - 16, - 17, - 18 - ], - "starting_column": 1, - "ending_column": 2 - } - }, - "signature": "bad(address)" - } } - ] + ], + "description": "MyConc.bad(address) (tests/unchecked_send-0.5.1.sol#2-4) ignores return value by dst.send(msg.value) (tests/unchecked_send-0.5.1.sol#3)\n", + "markdown": "[MyConc.bad(address)](tests/unchecked_send-0.5.1.sol#L2-L4) ignores return value by [dst.send(msg.value)](tests/unchecked_send-0.5.1.sol#L3)\n", + "check": "unchecked-send", + "impact": "Medium", + "confidence": "Medium" } ] } diff --git a/tests/expected_json/unchecked_send-0.5.1.unchecked-send.txt b/tests/expected_json/unchecked_send-0.5.1.unchecked-send.txt index 9feafa034..62d6a01ef 100644 --- a/tests/expected_json/unchecked_send-0.5.1.unchecked-send.txt +++ b/tests/expected_json/unchecked_send-0.5.1.unchecked-send.txt @@ -1,4 +1,4 @@ -INFO:Detectors: -MyConc.bad(address) (tests/unchecked_send-0.5.1.sol#2-4) ignores return value by send calls "dst.send(msg.value)" (tests/unchecked_send-0.5.1.sol#3) + +MyConc.bad(address) (tests/unchecked_send-0.5.1.sol#2-4) ignores return value by dst.send(msg.value) (tests/unchecked_send-0.5.1.sol#3) Reference: https://github.com/crytic/slither/wiki/Detector-Documentation#unchecked-send -INFO:Slither:tests/unchecked_send-0.5.1.sol analyzed (1 contracts), 1 result(s) found +tests/unchecked_send-0.5.1.sol analyzed (1 contracts with 1 detectors), 1 result(s) found diff --git a/tests/expected_json/uninitialized-0.5.1.uninitialized-state.json b/tests/expected_json/uninitialized-0.5.1.uninitialized-state.json index eca28e3ca..6b1497e20 100644 --- a/tests/expected_json/uninitialized-0.5.1.uninitialized-state.json +++ b/tests/expected_json/uninitialized-0.5.1.uninitialized-state.json @@ -4,10 +4,6 @@ "results": { "detectors": [ { - "check": "uninitialized-state", - "impact": "High", - "confidence": "High", - "description": "Uninitialized.destination (tests/uninitialized-0.5.1.sol#5) is never initialized. It is used in:\n\t- transfer (tests/uninitialized-0.5.1.sol#7-9)\n", "elements": [ { "type": "variable", @@ -104,13 +100,14 @@ "signature": "transfer()" } } - ] - }, - { + ], + "description": "Uninitialized.destination (tests/uninitialized-0.5.1.sol#5) is never initialized. It is used in:\n\t- Uninitialized.transfer() (tests/uninitialized-0.5.1.sol#7-9)\n", + "markdown": "[Uninitialized.destination](tests/uninitialized-0.5.1.sol#L5) is never initialized. It is used in:\n\t- [Uninitialized.transfer()](tests/uninitialized-0.5.1.sol#L7-L9)\n", "check": "uninitialized-state", "impact": "High", - "confidence": "High", - "description": "Test.balances (tests/uninitialized-0.5.1.sol#15) is never initialized. It is used in:\n\t- use (tests/uninitialized-0.5.1.sol#23-26)\n", + "confidence": "High" + }, + { "elements": [ { "type": "variable", @@ -218,13 +215,14 @@ "signature": "use()" } } - ] - }, - { + ], + "description": "Test.balances (tests/uninitialized-0.5.1.sol#15) is never initialized. It is used in:\n\t- Test.use() (tests/uninitialized-0.5.1.sol#23-26)\n", + "markdown": "[Test.balances](tests/uninitialized-0.5.1.sol#L15) is never initialized. It is used in:\n\t- [Test.use()](tests/uninitialized-0.5.1.sol#L23-L26)\n", "check": "uninitialized-state", "impact": "High", - "confidence": "High", - "description": "Test2.st (tests/uninitialized-0.5.1.sol#45) is never initialized. It is used in:\n\t- use (tests/uninitialized-0.5.1.sol#53-56)\n", + "confidence": "High" + }, + { "elements": [ { "type": "variable", @@ -338,13 +336,14 @@ "signature": "use()" } } - ] - }, - { + ], + "description": "Test2.st (tests/uninitialized-0.5.1.sol#45) is never initialized. It is used in:\n\t- Test2.use() (tests/uninitialized-0.5.1.sol#53-56)\n", + "markdown": "[Test2.st](tests/uninitialized-0.5.1.sol#L45) is never initialized. It is used in:\n\t- [Test2.use()](tests/uninitialized-0.5.1.sol#L53-L56)\n", "check": "uninitialized-state", "impact": "High", - "confidence": "High", - "description": "Test2.v (tests/uninitialized-0.5.1.sol#47) is never initialized. It is used in:\n\t- init (tests/uninitialized-0.5.1.sol#49-51)\n", + "confidence": "High" + }, + { "elements": [ { "type": "variable", @@ -457,7 +456,12 @@ "signature": "init()" } } - ] + ], + "description": "Test2.v (tests/uninitialized-0.5.1.sol#47) is never initialized. It is used in:\n\t- Test2.init() (tests/uninitialized-0.5.1.sol#49-51)\n", + "markdown": "[Test2.v](tests/uninitialized-0.5.1.sol#L47) is never initialized. It is used in:\n\t- [Test2.init()](tests/uninitialized-0.5.1.sol#L49-L51)\n", + "check": "uninitialized-state", + "impact": "High", + "confidence": "High" } ] } diff --git a/tests/expected_json/uninitialized-0.5.1.uninitialized-state.txt b/tests/expected_json/uninitialized-0.5.1.uninitialized-state.txt index ea27bfd31..9d4d66e14 100644 --- a/tests/expected_json/uninitialized-0.5.1.uninitialized-state.txt +++ b/tests/expected_json/uninitialized-0.5.1.uninitialized-state.txt @@ -1,11 +1,11 @@ -INFO:Detectors: + Uninitialized.destination (tests/uninitialized-0.5.1.sol#5) is never initialized. It is used in: - - transfer (tests/uninitialized-0.5.1.sol#7-9) + - Uninitialized.transfer() (tests/uninitialized-0.5.1.sol#7-9) Test.balances (tests/uninitialized-0.5.1.sol#15) is never initialized. It is used in: - - use (tests/uninitialized-0.5.1.sol#23-26) + - Test.use() (tests/uninitialized-0.5.1.sol#23-26) Test2.st (tests/uninitialized-0.5.1.sol#45) is never initialized. It is used in: - - use (tests/uninitialized-0.5.1.sol#53-56) + - Test2.use() (tests/uninitialized-0.5.1.sol#53-56) Test2.v (tests/uninitialized-0.5.1.sol#47) is never initialized. It is used in: - - init (tests/uninitialized-0.5.1.sol#49-51) + - Test2.init() (tests/uninitialized-0.5.1.sol#49-51) Reference: https://github.com/crytic/slither/wiki/Detector-Documentation#uninitialized-state-variables -INFO:Slither:tests/uninitialized-0.5.1.sol analyzed (4 contracts), 4 result(s) found +tests/uninitialized-0.5.1.sol analyzed (4 contracts with 1 detectors), 4 result(s) found diff --git a/tests/expected_json/uninitialized.uninitialized-state.json b/tests/expected_json/uninitialized.uninitialized-state.json index 288a04851..9e598c619 100644 --- a/tests/expected_json/uninitialized.uninitialized-state.json +++ b/tests/expected_json/uninitialized.uninitialized-state.json @@ -4,10 +4,6 @@ "results": { "detectors": [ { - "check": "uninitialized-state", - "impact": "High", - "confidence": "High", - "description": "Uninitialized.destination (tests/uninitialized.sol#5) is never initialized. It is used in:\n\t- transfer (tests/uninitialized.sol#7-9)\n", "elements": [ { "type": "variable", @@ -104,13 +100,14 @@ "signature": "transfer()" } } - ] - }, - { + ], + "description": "Uninitialized.destination (tests/uninitialized.sol#5) is never initialized. It is used in:\n\t- Uninitialized.transfer() (tests/uninitialized.sol#7-9)\n", + "markdown": "[Uninitialized.destination](tests/uninitialized.sol#L5) is never initialized. It is used in:\n\t- [Uninitialized.transfer()](tests/uninitialized.sol#L7-L9)\n", "check": "uninitialized-state", "impact": "High", - "confidence": "High", - "description": "Test.balances (tests/uninitialized.sol#15) is never initialized. It is used in:\n\t- use (tests/uninitialized.sol#23-26)\n", + "confidence": "High" + }, + { "elements": [ { "type": "variable", @@ -218,13 +215,14 @@ "signature": "use()" } } - ] - }, - { + ], + "description": "Test.balances (tests/uninitialized.sol#15) is never initialized. It is used in:\n\t- Test.use() (tests/uninitialized.sol#23-26)\n", + "markdown": "[Test.balances](tests/uninitialized.sol#L15) is never initialized. It is used in:\n\t- [Test.use()](tests/uninitialized.sol#L23-L26)\n", "check": "uninitialized-state", "impact": "High", - "confidence": "High", - "description": "Test2.st (tests/uninitialized.sol#45) is never initialized. It is used in:\n\t- use (tests/uninitialized.sol#53-56)\n", + "confidence": "High" + }, + { "elements": [ { "type": "variable", @@ -338,13 +336,14 @@ "signature": "use()" } } - ] - }, - { + ], + "description": "Test2.st (tests/uninitialized.sol#45) is never initialized. It is used in:\n\t- Test2.use() (tests/uninitialized.sol#53-56)\n", + "markdown": "[Test2.st](tests/uninitialized.sol#L45) is never initialized. It is used in:\n\t- [Test2.use()](tests/uninitialized.sol#L53-L56)\n", "check": "uninitialized-state", "impact": "High", - "confidence": "High", - "description": "Test2.v (tests/uninitialized.sol#47) is never initialized. It is used in:\n\t- init (tests/uninitialized.sol#49-51)\n", + "confidence": "High" + }, + { "elements": [ { "type": "variable", @@ -457,7 +456,12 @@ "signature": "init()" } } - ] + ], + "description": "Test2.v (tests/uninitialized.sol#47) is never initialized. It is used in:\n\t- Test2.init() (tests/uninitialized.sol#49-51)\n", + "markdown": "[Test2.v](tests/uninitialized.sol#L47) is never initialized. It is used in:\n\t- [Test2.init()](tests/uninitialized.sol#L49-L51)\n", + "check": "uninitialized-state", + "impact": "High", + "confidence": "High" } ] } diff --git a/tests/expected_json/uninitialized.uninitialized-state.txt b/tests/expected_json/uninitialized.uninitialized-state.txt index a516750bf..43fd9bb17 100644 --- a/tests/expected_json/uninitialized.uninitialized-state.txt +++ b/tests/expected_json/uninitialized.uninitialized-state.txt @@ -1,11 +1,11 @@ -INFO:Detectors: + Uninitialized.destination (tests/uninitialized.sol#5) is never initialized. It is used in: - - transfer (tests/uninitialized.sol#7-9) + - Uninitialized.transfer() (tests/uninitialized.sol#7-9) Test.balances (tests/uninitialized.sol#15) is never initialized. It is used in: - - use (tests/uninitialized.sol#23-26) + - Test.use() (tests/uninitialized.sol#23-26) Test2.st (tests/uninitialized.sol#45) is never initialized. It is used in: - - use (tests/uninitialized.sol#53-56) + - Test2.use() (tests/uninitialized.sol#53-56) Test2.v (tests/uninitialized.sol#47) is never initialized. It is used in: - - init (tests/uninitialized.sol#49-51) + - Test2.init() (tests/uninitialized.sol#49-51) Reference: https://github.com/crytic/slither/wiki/Detector-Documentation#uninitialized-state-variables -INFO:Slither:tests/uninitialized.sol analyzed (4 contracts), 4 result(s) found +tests/uninitialized.sol analyzed (4 contracts with 1 detectors), 4 result(s) found diff --git a/tests/expected_json/uninitialized_local_variable.uninitialized-local.json b/tests/expected_json/uninitialized_local_variable.uninitialized-local.json index 7434ab404..b401a27f4 100644 --- a/tests/expected_json/uninitialized_local_variable.uninitialized-local.json +++ b/tests/expected_json/uninitialized_local_variable.uninitialized-local.json @@ -4,10 +4,6 @@ "results": { "detectors": [ { - "check": "uninitialized-local", - "impact": "Medium", - "confidence": "Medium", - "description": "uint_not_init in Uninitialized.func() (tests/uninitialized_local_variable.sol#4) is a local variable never initialiazed\n", "elements": [ { "type": "variable", @@ -79,59 +75,13 @@ } } } - }, - { - "type": "function", - "name": "func", - "source_mapping": { - "start": 29, - "length": 143, - "filename_used": "/home/travis/build/crytic/slither/tests/uninitialized_local_variable.sol", - "filename_relative": "tests/uninitialized_local_variable.sol", - "filename_absolute": "/home/travis/build/crytic/slither/tests/uninitialized_local_variable.sol", - "filename_short": "tests/uninitialized_local_variable.sol", - "is_dependency": false, - "lines": [ - 3, - 4, - 5, - 6, - 7 - ], - "starting_column": 5, - "ending_column": 6 - }, - "type_specific_fields": { - "parent": { - "type": "contract", - "name": "Uninitialized", - "source_mapping": { - "start": 0, - "length": 179, - "filename_used": "/home/travis/build/crytic/slither/tests/uninitialized_local_variable.sol", - "filename_relative": "tests/uninitialized_local_variable.sol", - "filename_absolute": "/home/travis/build/crytic/slither/tests/uninitialized_local_variable.sol", - "filename_short": "tests/uninitialized_local_variable.sol", - "is_dependency": false, - "lines": [ - 1, - 2, - 3, - 4, - 5, - 6, - 7, - 8, - 9 - ], - "starting_column": 1, - "ending_column": 2 - } - }, - "signature": "func()" - } } - ] + ], + "description": "Uninitialized.func().uint_not_init (tests/uninitialized_local_variable.sol#4) is a local variable never initialiazed\n", + "markdown": "[Uninitialized.func().uint_not_init](tests/uninitialized_local_variable.sol#L4) is a local variable never initialiazed\n", + "check": "uninitialized-local", + "impact": "Medium", + "confidence": "Medium" } ] } diff --git a/tests/expected_json/uninitialized_local_variable.uninitialized-local.txt b/tests/expected_json/uninitialized_local_variable.uninitialized-local.txt index 6a013ffd9..6d5827508 100644 --- a/tests/expected_json/uninitialized_local_variable.uninitialized-local.txt +++ b/tests/expected_json/uninitialized_local_variable.uninitialized-local.txt @@ -1,4 +1,4 @@ -INFO:Detectors: -uint_not_init in Uninitialized.func() (tests/uninitialized_local_variable.sol#4) is a local variable never initialiazed + +Uninitialized.func().uint_not_init (tests/uninitialized_local_variable.sol#4) is a local variable never initialiazed Reference: https://github.com/crytic/slither/wiki/Detector-Documentation#uninitialized-local-variables -INFO:Slither:tests/uninitialized_local_variable.sol analyzed (1 contracts), 1 result(s) found +tests/uninitialized_local_variable.sol analyzed (1 contracts with 1 detectors), 1 result(s) found diff --git a/tests/expected_json/uninitialized_storage_pointer.uninitialized-storage.json b/tests/expected_json/uninitialized_storage_pointer.uninitialized-storage.json index 08364d527..7c587e3bd 100644 --- a/tests/expected_json/uninitialized_storage_pointer.uninitialized-storage.json +++ b/tests/expected_json/uninitialized_storage_pointer.uninitialized-storage.json @@ -4,10 +4,6 @@ "results": { "detectors": [ { - "check": "uninitialized-storage", - "impact": "High", - "confidence": "High", - "description": "st_bug in Uninitialized.func() (tests/uninitialized_storage_pointer.sol#10) is a storage variable never initialiazed\n", "elements": [ { "type": "variable", @@ -85,65 +81,13 @@ } } } - }, - { - "type": "function", - "name": "func", - "source_mapping": { - "start": 67, - "length": 143, - "filename_used": "/home/travis/build/crytic/slither/tests/uninitialized_storage_pointer.sol", - "filename_relative": "tests/uninitialized_storage_pointer.sol", - "filename_absolute": "/home/travis/build/crytic/slither/tests/uninitialized_storage_pointer.sol", - "filename_short": "tests/uninitialized_storage_pointer.sol", - "is_dependency": false, - "lines": [ - 7, - 8, - 9, - 10, - 11, - 12 - ], - "starting_column": 5, - "ending_column": 6 - }, - "type_specific_fields": { - "parent": { - "type": "contract", - "name": "Uninitialized", - "source_mapping": { - "start": 0, - "length": 217, - "filename_used": "/home/travis/build/crytic/slither/tests/uninitialized_storage_pointer.sol", - "filename_relative": "tests/uninitialized_storage_pointer.sol", - "filename_absolute": "/home/travis/build/crytic/slither/tests/uninitialized_storage_pointer.sol", - "filename_short": "tests/uninitialized_storage_pointer.sol", - "is_dependency": false, - "lines": [ - 1, - 2, - 3, - 4, - 5, - 6, - 7, - 8, - 9, - 10, - 11, - 12, - 13, - 14 - ], - "starting_column": 1, - "ending_column": 2 - } - }, - "signature": "func()" - } } - ] + ], + "description": "Uninitialized.func().st_bug (tests/uninitialized_storage_pointer.sol#10) is a storage variable never initialiazed\n", + "markdown": "[Uninitialized.func().st_bug](tests/uninitialized_storage_pointer.sol#L10) is a storage variable never initialiazed\n", + "check": "uninitialized-storage", + "impact": "High", + "confidence": "High" } ] } diff --git a/tests/expected_json/uninitialized_storage_pointer.uninitialized-storage.txt b/tests/expected_json/uninitialized_storage_pointer.uninitialized-storage.txt index 486ff5ec1..6c104545b 100644 --- a/tests/expected_json/uninitialized_storage_pointer.uninitialized-storage.txt +++ b/tests/expected_json/uninitialized_storage_pointer.uninitialized-storage.txt @@ -1,4 +1,4 @@ -INFO:Detectors: -st_bug in Uninitialized.func() (tests/uninitialized_storage_pointer.sol#10) is a storage variable never initialiazed + +Uninitialized.func().st_bug (tests/uninitialized_storage_pointer.sol#10) is a storage variable never initialiazed Reference: https://github.com/crytic/slither/wiki/Detector-Documentation#uninitialized-storage-variables -INFO:Slither:tests/uninitialized_storage_pointer.sol analyzed (1 contracts), 1 result(s) found +tests/uninitialized_storage_pointer.sol analyzed (1 contracts with 1 detectors), 1 result(s) found diff --git a/tests/expected_json/unused_return.unused-return.json b/tests/expected_json/unused_return.unused-return.json index e597b7392..1b84cb75f 100644 --- a/tests/expected_json/unused_return.unused-return.json +++ b/tests/expected_json/unused_return.unused-return.json @@ -4,11 +4,75 @@ "results": { "detectors": [ { - "check": "unused-return", - "impact": "Medium", - "confidence": "Medium", - "description": "User.test(Target) (tests/unused_return.sol#17-29) ignores return value by external calls \"t.f()\" (tests/unused_return.sol#18)\n", "elements": [ + { + "type": "function", + "name": "test", + "source_mapping": { + "start": 239, + "length": 354, + "filename_used": "/home/travis/build/crytic/slither/tests/unused_return.sol", + "filename_relative": "tests/unused_return.sol", + "filename_absolute": "/home/travis/build/crytic/slither/tests/unused_return.sol", + "filename_short": "tests/unused_return.sol", + "is_dependency": false, + "lines": [ + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29 + ], + "starting_column": 5, + "ending_column": 6 + }, + "type_specific_fields": { + "parent": { + "type": "contract", + "name": "User", + "source_mapping": { + "start": 189, + "length": 406, + "filename_used": "/home/travis/build/crytic/slither/tests/unused_return.sol", + "filename_relative": "tests/unused_return.sol", + "filename_absolute": "/home/travis/build/crytic/slither/tests/unused_return.sol", + "filename_short": "tests/unused_return.sol", + "is_dependency": false, + "lines": [ + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30 + ], + "starting_column": 1, + "ending_column": 2 + } + }, + "signature": "test(Target)" + } + }, { "type": "node", "name": "t.f()", @@ -96,7 +160,16 @@ } } } - }, + } + ], + "description": "User.test(Target) (tests/unused_return.sol#17-29) ignores return value by t.f() (tests/unused_return.sol#18)\n", + "markdown": "[User.test(Target)](tests/unused_return.sol#L17-L29) ignores return value by [t.f()](tests/unused_return.sol#L18)\n", + "check": "unused-return", + "impact": "Medium", + "confidence": "Medium" + }, + { + "elements": [ { "type": "function", "name": "test", @@ -164,15 +237,7 @@ }, "signature": "test(Target)" } - } - ] - }, - { - "check": "unused-return", - "impact": "Medium", - "confidence": "Medium", - "description": "User.test(Target) (tests/unused_return.sol#17-29) ignores return value by external calls \"a.add(0)\" (tests/unused_return.sol#22)\n", - "elements": [ + }, { "type": "node", "name": "a.add(0)", @@ -260,76 +325,13 @@ } } } - }, - { - "type": "function", - "name": "test", - "source_mapping": { - "start": 239, - "length": 354, - "filename_used": "/home/travis/build/crytic/slither/tests/unused_return.sol", - "filename_relative": "tests/unused_return.sol", - "filename_absolute": "/home/travis/build/crytic/slither/tests/unused_return.sol", - "filename_short": "tests/unused_return.sol", - "is_dependency": false, - "lines": [ - 17, - 18, - 19, - 20, - 21, - 22, - 23, - 24, - 25, - 26, - 27, - 28, - 29 - ], - "starting_column": 5, - "ending_column": 6 - }, - "type_specific_fields": { - "parent": { - "type": "contract", - "name": "User", - "source_mapping": { - "start": 189, - "length": 406, - "filename_used": "/home/travis/build/crytic/slither/tests/unused_return.sol", - "filename_relative": "tests/unused_return.sol", - "filename_absolute": "/home/travis/build/crytic/slither/tests/unused_return.sol", - "filename_short": "tests/unused_return.sol", - "is_dependency": false, - "lines": [ - 13, - 14, - 15, - 16, - 17, - 18, - 19, - 20, - 21, - 22, - 23, - 24, - 25, - 26, - 27, - 28, - 29, - 30 - ], - "starting_column": 1, - "ending_column": 2 - } - }, - "signature": "test(Target)" - } } - ] + ], + "description": "User.test(Target) (tests/unused_return.sol#17-29) ignores return value by a.add(0) (tests/unused_return.sol#22)\n", + "markdown": "[User.test(Target)](tests/unused_return.sol#L17-L29) ignores return value by [a.add(0)](tests/unused_return.sol#L22)\n", + "check": "unused-return", + "impact": "Medium", + "confidence": "Medium" } ] } diff --git a/tests/expected_json/unused_return.unused-return.txt b/tests/expected_json/unused_return.unused-return.txt index cae24dcf1..82ac0d99a 100644 --- a/tests/expected_json/unused_return.unused-return.txt +++ b/tests/expected_json/unused_return.unused-return.txt @@ -1,5 +1,5 @@ -INFO:Detectors: -User.test(Target) (tests/unused_return.sol#17-29) ignores return value by external calls "t.f()" (tests/unused_return.sol#18) -User.test(Target) (tests/unused_return.sol#17-29) ignores return value by external calls "a.add(0)" (tests/unused_return.sol#22) + +User.test(Target) (tests/unused_return.sol#17-29) ignores return value by t.f() (tests/unused_return.sol#18) +User.test(Target) (tests/unused_return.sol#17-29) ignores return value by a.add(0) (tests/unused_return.sol#22) Reference: https://github.com/crytic/slither/wiki/Detector-Documentation#unused-return -INFO:Slither:tests/unused_return.sol analyzed (3 contracts), 2 result(s) found +tests/unused_return.sol analyzed (3 contracts with 1 detectors), 2 result(s) found diff --git a/tests/expected_json/unused_state.unused-state.json b/tests/expected_json/unused_state.unused-state.json index 3a01bcb4a..58eec6bc6 100644 --- a/tests/expected_json/unused_state.unused-state.json +++ b/tests/expected_json/unused_state.unused-state.json @@ -4,10 +4,6 @@ "results": { "detectors": [ { - "check": "unused-state", - "impact": "Informational", - "confidence": "High", - "description": "A.unused (tests/unused_state.sol#4) is never used in B\n", "elements": [ { "type": "variable", @@ -76,13 +72,14 @@ "ending_column": 2 } } - ] - }, - { + ], + "description": "A.unused (tests/unused_state.sol#4) is never used in B (tests/unused_state.sol#11-16)\n", + "markdown": "[A.unused](tests/unused_state.sol#L4) is never used in [B](tests/unused_state.sol#L11-L16)\n", "check": "unused-state", "impact": "Informational", - "confidence": "High", - "description": "A.unused2 (tests/unused_state.sol#5) is never used in B\n", + "confidence": "High" + }, + { "elements": [ { "type": "variable", @@ -151,13 +148,14 @@ "ending_column": 2 } } - ] - }, - { + ], + "description": "A.unused2 (tests/unused_state.sol#5) is never used in B (tests/unused_state.sol#11-16)\n", + "markdown": "[A.unused2](tests/unused_state.sol#L5) is never used in [B](tests/unused_state.sol#L11-L16)\n", "check": "unused-state", "impact": "Informational", - "confidence": "High", - "description": "A.unused3 (tests/unused_state.sol#6) is never used in B\n", + "confidence": "High" + }, + { "elements": [ { "type": "variable", @@ -226,13 +224,14 @@ "ending_column": 2 } } - ] - }, - { + ], + "description": "A.unused3 (tests/unused_state.sol#6) is never used in B (tests/unused_state.sol#11-16)\n", + "markdown": "[A.unused3](tests/unused_state.sol#L6) is never used in [B](tests/unused_state.sol#L11-L16)\n", "check": "unused-state", "impact": "Informational", - "confidence": "High", - "description": "A.unused4 (tests/unused_state.sol#7) is never used in B\n", + "confidence": "High" + }, + { "elements": [ { "type": "variable", @@ -301,7 +300,12 @@ "ending_column": 2 } } - ] + ], + "description": "A.unused4 (tests/unused_state.sol#7) is never used in B (tests/unused_state.sol#11-16)\n", + "markdown": "[A.unused4](tests/unused_state.sol#L7) is never used in [B](tests/unused_state.sol#L11-L16)\n", + "check": "unused-state", + "impact": "Informational", + "confidence": "High" } ] } diff --git a/tests/expected_json/unused_state.unused-state.txt b/tests/expected_json/unused_state.unused-state.txt index 66be3708e..c719aa7ad 100644 --- a/tests/expected_json/unused_state.unused-state.txt +++ b/tests/expected_json/unused_state.unused-state.txt @@ -1,7 +1,7 @@ -INFO:Detectors: -A.unused (tests/unused_state.sol#4) is never used in B -A.unused2 (tests/unused_state.sol#5) is never used in B -A.unused3 (tests/unused_state.sol#6) is never used in B -A.unused4 (tests/unused_state.sol#7) is never used in B + +A.unused (tests/unused_state.sol#4) is never used in B (tests/unused_state.sol#11-16) +A.unused2 (tests/unused_state.sol#5) is never used in B (tests/unused_state.sol#11-16) +A.unused3 (tests/unused_state.sol#6) is never used in B (tests/unused_state.sol#11-16) +A.unused4 (tests/unused_state.sol#7) is never used in B (tests/unused_state.sol#11-16) Reference: https://github.com/crytic/slither/wiki/Detector-Documentation#unused-state-variables -INFO:Slither:tests/unused_state.sol analyzed (2 contracts), 4 result(s) found +tests/unused_state.sol analyzed (2 contracts with 1 detectors), 4 result(s) found diff --git a/tests/expected_json/void-cst.void-cst.json b/tests/expected_json/void-cst.void-cst.json index ab97b9d7d..1bb590390 100644 --- a/tests/expected_json/void-cst.void-cst.json +++ b/tests/expected_json/void-cst.void-cst.json @@ -4,10 +4,6 @@ "results": { "detectors": [ { - "check": "void-cst", - "impact": "Low", - "confidence": "High", - "description": "Void constructor called in D.constructor() (tests/void-cst.sol#10-12):\n\t-C() tests/void-cst.sol#10\n", "elements": [ { "type": "function", @@ -123,7 +119,12 @@ } } } - ] + ], + "description": "Void constructor called in D.constructor() (tests/void-cst.sol#10-12):\n\t- C() (tests/void-cst.sol#10)\n", + "markdown": "Void constructor called in [D.constructor()](tests/void-cst.sol#L10-L12):\n\t- [C()](tests/void-cst.sol#L10)\n", + "check": "void-cst", + "impact": "Low", + "confidence": "High" } ] } diff --git a/tests/expected_json/void-cst.void-cst.txt b/tests/expected_json/void-cst.void-cst.txt index cc3473967..95daeabe6 100644 --- a/tests/expected_json/void-cst.void-cst.txt +++ b/tests/expected_json/void-cst.void-cst.txt @@ -1,5 +1,5 @@ -INFO:Detectors: + Void constructor called in D.constructor() (tests/void-cst.sol#10-12): - -C() tests/void-cst.sol#10 + - C() (tests/void-cst.sol#10) Reference: https://github.com/crytic/slither/wiki/Detector-Documentation#void-constructor -INFO:Slither:tests/void-cst.sol analyzed (2 contracts), 1 result(s) found +tests/void-cst.sol analyzed (2 contracts with 1 detectors), 1 result(s) found From e551a0b5165a0852da29eb854cbf19e21d9b9b3f Mon Sep 17 00:00:00 2001 From: Josselin Date: Mon, 4 Nov 2019 15:38:04 +0100 Subject: [PATCH 211/223] Incorrect solc: add 0.5.12/5.0.13 --- slither/detectors/attributes/incorrect_solc.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/slither/detectors/attributes/incorrect_solc.py b/slither/detectors/attributes/incorrect_solc.py index 105a72561..a8ce08246 100644 --- a/slither/detectors/attributes/incorrect_solc.py +++ b/slither/detectors/attributes/incorrect_solc.py @@ -43,7 +43,7 @@ Use Solidity 0.4.25 or 0.5.3. Consider using the latest version of Solidity for # Indicates the allowed versions. ALLOWED_VERSIONS = ["0.4.25", "0.4.26", "0.5.3"] # Indicates the versions too recent. - TOO_RECENT_VERSIONS = ["0.5.4", "0.5.7", "0.5.8", "0.5.9", "0.5.10", "0.5.11"] + TOO_RECENT_VERSIONS = ["0.5.4", "0.5.7", "0.5.8", "0.5.9", "0.5.10", "0.5.11", "0.5.12", "0.5.13"] # Indicates the versions that should not be used. BUGGY_VERSIONS = ["0.4.22", "0.5.5", "0.5.6", "^0.4.22", "^0.5.5", "^0.5.6"] From ff59854e8a1c750cbcf57535241047a2d22329f5 Mon Sep 17 00:00:00 2001 From: Josselin Date: Wed, 6 Nov 2019 11:41:27 +0100 Subject: [PATCH 212/223] slither erc check: - Rename tool to slither-check-erc - Use json_utils for output - Simple test case --- .travis.yml | 1 + scripts/travis_test_erc.sh | 20 +++++ setup.py | 2 +- slither/tools/erc_conformance/__main__.py | 21 +++++- slither/tools/erc_conformance/erc/erc20.py | 15 ++-- slither/tools/erc_conformance/erc/ercs.py | 87 +++++++++++----------- tests/check-erc/erc20.sol | 6 ++ tests/check-erc/test_1.txt | 21 ++++++ 8 files changed, 119 insertions(+), 54 deletions(-) create mode 100755 scripts/travis_test_erc.sh create mode 100644 tests/check-erc/erc20.sol create mode 100644 tests/check-erc/test_1.txt diff --git a/.travis.yml b/.travis.yml index b33582446..f55af74a3 100644 --- a/.travis.yml +++ b/.travis.yml @@ -19,6 +19,7 @@ env: - TEST_SUITE=scripts/travis_test_printers.sh - TEST_SUITE=scripts/travis_test_slither_config.sh - TEST_SUITE=scripts/travis_test_simil.sh + - TEST_SUITE=scripts/travis_test_erc.sh branches: only: - master diff --git a/scripts/travis_test_erc.sh b/scripts/travis_test_erc.sh new file mode 100755 index 000000000..908760631 --- /dev/null +++ b/scripts/travis_test_erc.sh @@ -0,0 +1,20 @@ +#!/usr/bin/env bash + +### Test slither-check-erc + +DIR_TESTS="tests/check-erc" + +slither-check-erc "$DIR_TESTS/erc20.sol" ERC20 --solc solc-0.5.0 > test_1.txt 2>&1 +DIFF=$(diff test_1.txt "$DIR_TESTS/test_1.txt") +if [ "$DIFF" != "" ] +then + echo "slither-check-erc 1 failed" + cat test_1.txt + echo "" + cat "$DIR_TESTS/test_1.txt" + exit -1 +fi + + +rm test_1.txt + diff --git a/setup.py b/setup.py index 1ea940498..843adf651 100644 --- a/setup.py +++ b/setup.py @@ -22,7 +22,7 @@ setup( 'slither-simil = slither.tools.similarity.__main__:main', 'slither-flat = slither.tools.flattening.__main__:main', 'slither-format = slither.tools.slither_format.__main__:main', - 'slither-erc = slither.tools.erc_conformance.__main__:main' + 'slither-check-erc = slither.tools.erc_conformance.__main__:main' ] } ) diff --git a/slither/tools/erc_conformance/__main__.py b/slither/tools/erc_conformance/__main__.py index 73b096971..f581db047 100644 --- a/slither/tools/erc_conformance/__main__.py +++ b/slither/tools/erc_conformance/__main__.py @@ -5,6 +5,7 @@ from collections import defaultdict from slither import Slither from crytic_compile import cryticparser from slither.utils.erc import ERCS +from slither.utils.json_utils import output_json from .erc.ercs import generic_erc_checks from .erc.erc20 import check_erc20 @@ -46,11 +47,22 @@ def parse_args(): default="erc20", ) + parser.add_argument('--json', + help='Export the results as a JSON file ("--json -" to export to stdout)', + action='store', + default=False) + # Add default arguments from crytic-compile cryticparser.init(parser) return parser.parse_args() +def _log_error(err, args): + if args.json: + output_json(args.json, str(err), {"upgradeability-check": []}) + + logger.error(err) + def main(): args = parse_args() @@ -64,7 +76,8 @@ def main(): contract = slither.get_contract_from_name(args.contract_name) if not contract: - logger.error(f'Contract not found: {args.contract_name}') + err = f'Contract not found: {args.contract_name}' + _log_error(err, args) return # First elem is the function, second is the event erc = ERCS[args.erc.upper()] @@ -74,9 +87,13 @@ def main(): ADDITIONAL_CHECKS[args.erc.upper()](contract, ret) else: - logger.error(f'Incorrect ERC selected {args.erc}') + err = f'Incorrect ERC selected {args.erc}' + _log_error(err, args) return + if args.json: + output_json(args.json, None, {"upgradeability-check": ret}) + if __name__ == '__main__': main() diff --git a/slither/tools/erc_conformance/erc/erc20.py b/slither/tools/erc_conformance/erc/erc20.py index 42a8dbfef..3143ed34d 100644 --- a/slither/tools/erc_conformance/erc/erc20.py +++ b/slither/tools/erc_conformance/erc/erc20.py @@ -1,7 +1,10 @@ import logging +from slither.utils import json_utils + logger = logging.getLogger("Slither-conformance") + def approval_race_condition(contract, ret): increaseAllowance = contract.get_function_from_signature('increaseAllowance(address,uint256)') @@ -13,14 +16,14 @@ def approval_race_condition(contract, ret): logger.info(txt) else: txt = f'\t[ ] {contract.name} is not protected for the ERC20 approval race condition' - ret["lack_of_erc20_race_condition_protection"].append({ - "description": txt, - "contract": contract.name - }) logger.info(txt) -def check_erc20(contract, ret, explored=None): + lack_of_erc20_race_condition_protection = json_utils.generate_json_result(txt) + json_utils.add_contract_to_json(contract, lack_of_erc20_race_condition_protection) + ret["lack_of_erc20_race_condition_protection"].append(lack_of_erc20_race_condition_protection) + +def check_erc20(contract, ret, explored=None): if explored is None: explored = set() @@ -32,5 +35,3 @@ def check_erc20(contract, ret, explored=None): check_erc20(derived_contract, ret, explored) return ret - - diff --git a/slither/tools/erc_conformance/erc/ercs.py b/slither/tools/erc_conformance/erc/ercs.py index 3b5117420..523609263 100644 --- a/slither/tools/erc_conformance/erc/ercs.py +++ b/slither/tools/erc_conformance/erc/ercs.py @@ -1,8 +1,7 @@ import logging -from collections import defaultdict -from slither.core.solidity_types import MappingType from slither.slithir.operations import EventCall +from slither.utils import json_utils from slither.utils.type import export_nested_types_from_variable, export_return_type_from_variable logger = logging.getLogger("Slither-conformance") @@ -26,12 +25,12 @@ def _check_signature(erc_function, contract, ret): if not state_variable_as_function or not state_variable_as_function.visibility in ['public', 'external']: txt = f'[ ] {sig} is missing {"" if required else "(optional)"}' logger.info(txt) - ret["missing_function"].append({ - "description": txt, - "contract": contract.name, + missing_func = json_utils.generate_json_result(txt, additional_fields={ "function": sig, "required": required }) + json_utils.add_contract_to_json(contract, missing_func) + ret["missing_function"].append(missing_func) return types = [str(x) for x in export_nested_types_from_variable(state_variable_as_function)] @@ -39,12 +38,12 @@ def _check_signature(erc_function, contract, ret): if types != parameters: txt = f'[ ] {sig} is missing {"" if required else "(optional)"}' logger.info(txt) - ret["missing_function"].append({ - "description": txt, - "contract": contract.name, + missing_func = json_utils.generate_json_result(txt, additional_fields={ "function": sig, "required": required }) + json_utils.add_contract_to_json(contract, missing_func) + ret["missing_function"].append(missing_func) return function_return_type = [export_return_type_from_variable(state_variable_as_function)] @@ -64,27 +63,28 @@ def _check_signature(erc_function, contract, ret): logger.info(txt) else: txt = f'\t[ ] {sig} -> () should return {return_type}' - ret["incorrect_return_type"].append({ - "description": txt, - "contract": contract.name, - "function": sig, + logger.info(txt) + + incorrect_return = json_utils.generate_json_result(txt, additional_fields={ "expected_return_type": return_type, "actual_return_type": function_return_type }) - logger.info(txt) + json_utils.add_function_to_json(function, incorrect_return) + ret["incorrect_return_type"].append(incorrect_return) + elif not return_type: txt = f'\t[✓] {sig} -> () (correct return type)' logger.info(txt) else: txt = f'\t[ ] {sig} -> () should return {return_type}' - ret["incorrect_return_type"].append({ - "description": txt, - "contract": contract.name, - "function": sig, + logger.info(txt) + + incorrect_return = json_utils.generate_json_result(txt, additional_fields={ "expected_return_type": return_type, - "actual_return_type": "" + "actual_return_type": function_return_type }) - logger.info(txt) + json_utils.add_function_to_json(function, incorrect_return) + ret["incorrect_return_type"].append(incorrect_return) if view: if function_view: @@ -92,26 +92,26 @@ def _check_signature(erc_function, contract, ret): logger.info(txt) else: txt = f'\t[ ] {sig} should be view' - ret["should_be_view"].append({ - "description": txt, - "contract": contract.name, - "function": sig - }) logger.info(txt) + should_be_view = json_utils.generate_json_result(txt) + json_utils.add_function_to_json(function, should_be_view) + ret["should_be_view"].append(should_be_view) + if events: for event in events: event_sig = f'{event.name}({",".join(event.parameters)})' if not function: txt = f'\t[ ] Must emit be view {event_sig}' - ret["missing_event_emmited"].append({ - "description": txt, - "contract": contract.name, - "function": sig, + logger.info(txt) + + missing_event_emmited = json_utils.generate_json_result(txt, additional_fields={ "missing_event": event_sig }) - logger.info(txt) + json_utils.add_function_to_json(function, missing_event_emmited) + ret["missing_event_emmited"].append(missing_event_emmited) + else: event_found = False for ir in function.all_slithir_operations(): @@ -125,15 +125,13 @@ def _check_signature(erc_function, contract, ret): logger.info(txt) else: txt = f'\t[ ] Must emit be view {event_sig}' - ret["missing_event_emmited"].append({ - "description": txt, - "contract": contract.name, - "function": sig, - "missing_event": event_sig - }) logger.info(txt) - + missing_event_emmited = json_utils.generate_json_result(txt, additional_fields={ + "missing_event": event_sig + }) + json_utils.add_function_to_json(function, missing_event_emmited) + ret["missing_event_emmited"].append(missing_event_emmited) def _check_events(erc_event, contract, ret): @@ -147,11 +145,13 @@ def _check_events(erc_event, contract, ret): if not event: txt = f'[ ] {sig} is missing' logger.info(txt) - ret["missing_event"].append({ - "description": txt, - "contract": contract.name, + + missing_event = json_utils.generate_json_result(txt, additional_fields={ "event": sig }) + json_utils.add_contract_to_json(contract, missing_event) + ret["missing_event"].append(missing_event) + return txt = f'[✓] {sig} is present' @@ -165,13 +165,12 @@ def _check_events(erc_event, contract, ret): else: txt = f'\t[ ] parameter {i} should be indexed' logger.info(txt) - ret["missing_event_index"].append({ - "description": txt, - "contract": contract.name, - "event": sig, + + missing_event_index = json_utils.generate_json_result(txt, additional_fields={ "missing_index": i }) - + json_utils.add_event_to_json(event, missing_event_index) + ret["missing_event_index"].append(missing_event_index) def generic_erc_checks(contract, erc_functions, erc_events, ret, explored=None): diff --git a/tests/check-erc/erc20.sol b/tests/check-erc/erc20.sol new file mode 100644 index 000000000..8ba65a918 --- /dev/null +++ b/tests/check-erc/erc20.sol @@ -0,0 +1,6 @@ +contract ERC20{ + + + uint public totalSupply; + +} diff --git a/tests/check-erc/test_1.txt b/tests/check-erc/test_1.txt new file mode 100644 index 000000000..1e088017f --- /dev/null +++ b/tests/check-erc/test_1.txt @@ -0,0 +1,21 @@ +# Check ERC20 + +## Check functions +[✓] totalSupply() is present + [✓] totalSupply() -> () (correct return value) + [✓] totalSupply() is view +[ ] balanceOf(address) is missing +[ ] transfer(address,uint256) is missing +[ ] transferFrom(address,address,uint256) is missing +[ ] approve(address,uint256) is missing +[ ] allowance(address,address) is missing +[ ] name() is missing (optional) +[ ] symbol() is missing (optional) +[ ] decimals() is missing (optional) + +## Check events +[ ] Transfer(address,address,uint256) is missing +[ ] Approval(address,address,uint256) is missing + + + [ ] ERC20 is not protected for the ERC20 approval race condition From f18d0724beb23fdb97eb90fec0a3bc3507e1ddfb Mon Sep 17 00:00:00 2001 From: Josselin Date: Wed, 6 Nov 2019 12:03:34 +0100 Subject: [PATCH 213/223] Upgradeability: improve constant conformance checks in case of new variables in the new contract --- .../tools/upgradeability/constant_checks.py | 28 +++++++++++++++---- 1 file changed, 23 insertions(+), 5 deletions(-) diff --git a/slither/tools/upgradeability/constant_checks.py b/slither/tools/upgradeability/constant_checks.py index 413e95dcf..d66b41fc2 100644 --- a/slither/tools/upgradeability/constant_checks.py +++ b/slither/tools/upgradeability/constant_checks.py @@ -20,17 +20,32 @@ def constant_conformance_check(contract_v1, contract_v2): state_variables_v1 = contract_v1.state_variables state_variables_v2 = contract_v2.state_variables - for idx in range(0, len(state_variables_v1)): - state_v1 = contract_v1.state_variables[idx] - - if len(state_variables_v2) <= idx: + v2_additional_variables = len(state_variables_v2) - len(state_variables_v1) + if v2_additional_variables < 0: + v2_additional_variables = 0 + + # We keep two index, because we need to have them out of sync if v2 + # has additional non constant variables + idx_v1 = 0 + idx_v2 = 0 + while idx_v1 < len(state_variables_v1): + + state_v1 = contract_v1.state_variables[idx_v1] + if len(state_variables_v2) <= idx_v2: break - state_v2 = contract_v2.state_variables[idx] + state_v2 = contract_v2.state_variables[idx_v2] if state_v2: if state_v1.is_constant: if not state_v2.is_constant: + + # If v2 has additional non constant variables, we need to skip them + if (state_v1.name != state_v2.name or state_v1.type != state_v2.type) and v2_additional_variables>0: + v2_additional_variables -= 1 + idx_v2 += 1 + continue + info = f'{state_v1.canonical_name} ({state_v1.source_mapping_str}) was constant and {state_v2.canonical_name} is not ({state_v2.source_mapping_str})' logger.info(red(info)) @@ -61,6 +76,9 @@ def constant_conformance_check(contract_v1, contract_v2): error_found = True + idx_v1 += 1 + idx_v2 += 1 + if not error_found: logger.info(green('No error found')) From 6aecebcd8e2f611dac034636808239fb90f948a2 Mon Sep 17 00:00:00 2001 From: Josselin Date: Wed, 6 Nov 2019 12:08:03 +0100 Subject: [PATCH 214/223] Add missing __init__.py --- slither/tools/erc_conformance/erc/__init__.py | 0 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 slither/tools/erc_conformance/erc/__init__.py diff --git a/slither/tools/erc_conformance/erc/__init__.py b/slither/tools/erc_conformance/erc/__init__.py new file mode 100644 index 000000000..e69de29bb From 32022bd7284112e79f9297b46c9c8731716b2313 Mon Sep 17 00:00:00 2001 From: Josselin Date: Wed, 6 Nov 2019 13:53:14 +0100 Subject: [PATCH 215/223] Add slither.state_variables --- slither/core/slither_core.py | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/slither/core/slither_core.py b/slither/core/slither_core.py index 6442b2443..7ec7f0c79 100644 --- a/slither/core/slither_core.py +++ b/slither/core/slither_core.py @@ -27,6 +27,7 @@ class Slither(Context): self._raw_source_code = {} self._all_functions = set() self._all_modifiers = set() + self._all_state_variables = None self._previous_results_filename = 'slither.db.json' self._results_to_hide = [] @@ -158,6 +159,20 @@ class Slither(Context): if isinstance(ir, InternalCall): ir.function.add_reachable_from_node(node, ir) + # endregion + ################################################################################### + ################################################################################### + # region Variables + ################################################################################### + ################################################################################### + + @property + def state_variables(self): + if self._all_state_variables is None: + state_variables = [c.state_variables for c in self.contracts] + state_variables = [item for sublist in state_variables for item in sublist] + self._all_state_variables = set(state_variables) + return list(self._all_state_variables) # endregion ################################################################################### From b872f70738f8394533ae235dccfa1a441889f38c Mon Sep 17 00:00:00 2001 From: Josselin Date: Wed, 6 Nov 2019 15:04:21 +0100 Subject: [PATCH 216/223] Create slither-check-kspec tool --- .travis.yml | 1 + scripts/travis_test_kspec.sh | 16 +++ setup.py | 3 +- slither/tools/kspec_coverage/__init__.py | 1 + slither/tools/kspec_coverage/__main__.py | 58 ++++++++ slither/tools/kspec_coverage/analysis.py | 131 ++++++++++++++++++ .../tools/kspec_coverage/kspec_coverage.py | 14 ++ tests/check-kspec/safeAdd/safeAdd.sol | 10 ++ tests/check-kspec/safeAdd/spec.md | 29 ++++ tests/check-kspec/test_1.txt | 4 + 10 files changed, 266 insertions(+), 1 deletion(-) create mode 100755 scripts/travis_test_kspec.sh create mode 100755 slither/tools/kspec_coverage/__init__.py create mode 100644 slither/tools/kspec_coverage/__main__.py create mode 100755 slither/tools/kspec_coverage/analysis.py create mode 100755 slither/tools/kspec_coverage/kspec_coverage.py create mode 100644 tests/check-kspec/safeAdd/safeAdd.sol create mode 100644 tests/check-kspec/safeAdd/spec.md create mode 100644 tests/check-kspec/test_1.txt diff --git a/.travis.yml b/.travis.yml index f55af74a3..088d1a14f 100644 --- a/.travis.yml +++ b/.travis.yml @@ -20,6 +20,7 @@ env: - TEST_SUITE=scripts/travis_test_slither_config.sh - TEST_SUITE=scripts/travis_test_simil.sh - TEST_SUITE=scripts/travis_test_erc.sh + - TEST_SUITE=scripts/travis_test_kspec.sh branches: only: - master diff --git a/scripts/travis_test_kspec.sh b/scripts/travis_test_kspec.sh new file mode 100755 index 000000000..341af9526 --- /dev/null +++ b/scripts/travis_test_kspec.sh @@ -0,0 +1,16 @@ +#!/bin/bash + +DIR_TESTS="tests/check-kspec" + +slither-check-kspec "$DIR_TESTS/safeAdd/safeAdd.sol" "$DIR_TESTS/safeAdd/spec.md" --solc solc-0.5.0 > test_1.txt 2>&1 +DIFF=$(diff test_1.txt "$DIR_TESTS/test_1.txt") +if [ "$DIFF" != "" ] +then + echo "slither-check-upgradeability 1 failed" + cat test_1.txt + echo "" + cat "$DIR_TESTS/test_1.txt" + exit -1 +fi + +rm test_1.txt diff --git a/setup.py b/setup.py index 843adf651..d1064dbd0 100644 --- a/setup.py +++ b/setup.py @@ -22,7 +22,8 @@ setup( 'slither-simil = slither.tools.similarity.__main__:main', 'slither-flat = slither.tools.flattening.__main__:main', 'slither-format = slither.tools.slither_format.__main__:main', - 'slither-check-erc = slither.tools.erc_conformance.__main__:main' + 'slither-check-erc = slither.tools.erc_conformance.__main__:main', + 'slither-check-kspec = slither.tools.kspec_coverage.__main__:main' ] } ) diff --git a/slither/tools/kspec_coverage/__init__.py b/slither/tools/kspec_coverage/__init__.py new file mode 100755 index 000000000..286b5a55a --- /dev/null +++ b/slither/tools/kspec_coverage/__init__.py @@ -0,0 +1 @@ +from .analysis import run_analysis diff --git a/slither/tools/kspec_coverage/__main__.py b/slither/tools/kspec_coverage/__main__.py new file mode 100644 index 000000000..47dc5c9fa --- /dev/null +++ b/slither/tools/kspec_coverage/__main__.py @@ -0,0 +1,58 @@ +import sys +import logging +import argparse +from slither import Slither +from .kspec_coverage import kspec_coverage +from crytic_compile import cryticparser + +logging.basicConfig() +logger = logging.getLogger("Slither.kspec") +logger.setLevel(logging.INFO) + +ch = logging.StreamHandler() +ch.setLevel(logging.INFO) +formatter = logging.Formatter('%(message)s') +logger.addHandler(ch) +logger.handlers[0].setFormatter(formatter) +logger.propagate = False + +def parse_args(): + """ + Parse the underlying arguments for the program. + :return: Returns the arguments for the program. + """ + parser = argparse.ArgumentParser(description='slither-kspec-coverage', + usage='slither-kspec-coverage contract.sol kspec.md') + + parser.add_argument('contract', help='The filename of the contract or truffle directory to analyze.') + parser.add_argument('kspec', help='The filename of the Klab spec markdown for the analyzed contract(s)') + + parser.add_argument('--version', help='displays the current version', version='0.1.0',action='version') + parser.add_argument('--json', + help='Export the results as a JSON file ("--json -" to export to stdout)', + action='store', + default=False + ) + + cryticparser.init(parser) + + if len(sys.argv) < 2: + parser.print_help(sys.stderr) + sys.exit(1) + + return parser.parse_args() + + +def main(): + # ------------------------------ + # Usage: slither-kspec-coverage contract kspec + # Example: slither-kspec-coverage contract.sol kspec.md + # ------------------------------ + # Parse all arguments + + args = parse_args() + + kspec_coverage(args) + +if __name__ == '__main__': + main() diff --git a/slither/tools/kspec_coverage/analysis.py b/slither/tools/kspec_coverage/analysis.py new file mode 100755 index 000000000..b95e79f1f --- /dev/null +++ b/slither/tools/kspec_coverage/analysis.py @@ -0,0 +1,131 @@ +import re +import logging +from slither.utils.colors import yellow, green, red +from slither.utils import json_utils + +logging.basicConfig(level=logging.WARNING) +logger = logging.getLogger('Slither.kspec') + +def _refactor_type(type): + return { + 'uint': 'uint256', + 'int': 'int256' + }.get(type, type) + +def _get_all_covered_kspec_functions(target): + # Create a set of our discovered functions which are covered + covered_functions = set() + + BEHAVIOUR_PATTERN = re.compile('behaviour\s+(\S+)\s+of\s+(\S+)') + INTERFACE_PATTERN = re.compile('interface\s+([^\r\n]+)') + + # Read the file contents + with open(target, 'r', encoding='utf8') as target_file: + lines = target_file.readlines() + + # Loop for each line, if a line matches our behaviour regex, and the next one matches our interface regex, + # we add our finding + i = 0 + while i < len(lines): + match = BEHAVIOUR_PATTERN.match(lines[i]) + if match: + contract_name = match.groups()[1] + match = INTERFACE_PATTERN.match(lines[i + 1]) + if match: + function_full_name = match.groups()[0] + start, end = function_full_name.index('(') + 1, function_full_name.index(')') + function_arguments = function_full_name[start:end].split(',') + function_arguments = [_refactor_type(arg.strip().split(' ')[0]) for arg in function_arguments] + function_full_name = function_full_name[:start] + ','.join(function_arguments) + ')' + covered_functions.add((contract_name, function_full_name)) + i += 1 + i += 1 + return covered_functions + + +def _get_slither_functions(slither): + # Use contract == contract_declarer to avoid dupplicate + all_functions_declared = [f for f in slither.functions if (f.contract == f.contract_declarer + and not f.is_constructor + and not f.is_empty + and not f.is_constructor_variables)] + # Use list(set()) because same state variable instances can be shared accross contracts + # TODO: integrate state variables + # all_functions_declared += list(set([s for s in slither.state_variables if s.visibility in ['public', 'external']])) + # + slither_functions = {(function.contract.name, function.full_name): function for function in all_functions_declared} + + return slither_functions + +def _generate_output(kspec, message, color, generate_json): + info = "" + for function in kspec: + info += f"{message} {function.contract.name}.{function.full_name}" + if info: + logger.info(color(info)) + + if generate_json: + json_kspec_present = json_utils.generate_json_result(info) + for function in kspec: + json_utils.add_function_to_json(function, json_kspec_present) + return json_kspec_present + return None + +def _generate_output_unresolved(kspec, message, color, generate_json): + info = "" + for contract, function in kspec: + info += f"{message} {contract}.{function}" + if info: + logger.info(color(info)) + + if generate_json: + json_kspec_present = json_utils.generate_json_result(info, additional_fields={"signatures": kspec}) + return json_kspec_present + return None + + + +def _run_coverage_analysis(args, slither, kspec_functions): + # Collect all slither functions + slither_functions = _get_slither_functions(slither) + + # Determine which klab specs were not resolved. + slither_functions_set = set(slither_functions) + kspec_functions_resolved = kspec_functions & slither_functions_set + kspec_functions_unresolved = kspec_functions - kspec_functions_resolved + + + kspec_missing = [] + kspec_present = [] + + for slither_func_desc in sorted(slither_functions_set): + slither_func = slither_functions[slither_func_desc] + + if slither_func_desc in kspec_functions: + kspec_present.append(slither_func) + else: + kspec_missing.append(slither_func) + + logger.info('## Check for functions coverage') + json_kspec_present = _generate_output(kspec_present, "[✓]", green, args.json) + json_kspec_missing = _generate_output(kspec_missing, "[ ] (Missing)", red, args.json) + json_kspec_unresolved = _generate_output_unresolved(kspec_functions_unresolved, + "[ ] (Unresolved)", + yellow, + args.json) + + # Handle unresolved kspecs + if args.json: + json_utils.output_json(args.json, None, { + "kspec_present": json_kspec_present, + "kspec_missing": json_kspec_missing, + "kspec_unresolved": json_kspec_unresolved + }) + +def run_analysis(args, slither, kspec): + # Get all of our kspec'd functions (tuple(contract_name, function_name)). + kspec_functions = _get_all_covered_kspec_functions(kspec) + + # Run coverage analysis + _run_coverage_analysis(args, slither, kspec_functions) + diff --git a/slither/tools/kspec_coverage/kspec_coverage.py b/slither/tools/kspec_coverage/kspec_coverage.py new file mode 100755 index 000000000..43434a364 --- /dev/null +++ b/slither/tools/kspec_coverage/kspec_coverage.py @@ -0,0 +1,14 @@ +from slither.tools.kspec_coverage.analysis import run_analysis +from slither import Slither + +def kspec_coverage(args): + + contract = args.contract + kspec = args.kspec + + slither = Slither(contract) + + # Run the analysis on the Klab specs + run_analysis(args, slither, kspec) + + diff --git a/tests/check-kspec/safeAdd/safeAdd.sol b/tests/check-kspec/safeAdd/safeAdd.sol new file mode 100644 index 000000000..04c49e834 --- /dev/null +++ b/tests/check-kspec/safeAdd/safeAdd.sol @@ -0,0 +1,10 @@ +pragma solidity >=0.4.24; + +contract SafeAdd { + function add(uint x, uint y) public pure returns (uint z) { + require((z = x + y) >= x); + } + function add_v2(uint x, uint y) public pure returns (uint z) { + require((z = x + y) >= x); + } +} diff --git a/tests/check-kspec/safeAdd/spec.md b/tests/check-kspec/safeAdd/spec.md new file mode 100644 index 000000000..5fa1f516a --- /dev/null +++ b/tests/check-kspec/safeAdd/spec.md @@ -0,0 +1,29 @@ + +```act +behaviour add of SafeAdd +interface add(uint256 X, uint256 Y) + +iff in range uint256 + + X + Y + +iff + + VCallValue == 0 + +returns X + Y +``` +```act +behaviour addv2 of SafeAdd +interface addv2(uint256 X, uint256 Y) + +iff in range uint256 + + X + Y + +iff + + VCallValue == 0 + +returns X + Y +``` diff --git a/tests/check-kspec/test_1.txt b/tests/check-kspec/test_1.txt new file mode 100644 index 000000000..f7334ba30 --- /dev/null +++ b/tests/check-kspec/test_1.txt @@ -0,0 +1,4 @@ +## Check for functions coverage +[✓] SafeAdd.add(uint256,uint256) +[ ] (Missing) SafeAdd.add_v2(uint256,uint256) +[ ] (Unresolved) SafeAdd.addv2(uint256,uint256) From 6e35805137a86de1fb3977b5632b05a20b449238 Mon Sep 17 00:00:00 2001 From: Josselin Date: Wed, 6 Nov 2019 16:25:21 +0100 Subject: [PATCH 217/223] kspec: minor improvements --- slither/tools/kspec_coverage/analysis.py | 37 +++++++++++++------ .../tools/kspec_coverage/kspec_coverage.py | 2 +- 2 files changed, 27 insertions(+), 12 deletions(-) diff --git a/slither/tools/kspec_coverage/analysis.py b/slither/tools/kspec_coverage/analysis.py index b95e79f1f..6ca9f9a83 100755 --- a/slither/tools/kspec_coverage/analysis.py +++ b/slither/tools/kspec_coverage/analysis.py @@ -1,5 +1,8 @@ import re import logging + +from slither.core.declarations import Function +from slither.core.variables.variable import Variable from slither.utils.colors import yellow, green, red from slither.utils import json_utils @@ -46,13 +49,12 @@ def _get_all_covered_kspec_functions(target): def _get_slither_functions(slither): # Use contract == contract_declarer to avoid dupplicate all_functions_declared = [f for f in slither.functions if (f.contract == f.contract_declarer + and f.is_implemented and not f.is_constructor - and not f.is_empty and not f.is_constructor_variables)] # Use list(set()) because same state variable instances can be shared accross contracts # TODO: integrate state variables - # all_functions_declared += list(set([s for s in slither.state_variables if s.visibility in ['public', 'external']])) - # + all_functions_declared += list(set([s for s in slither.state_variables if s.visibility in ['public', 'external']])) slither_functions = {(function.contract.name, function.full_name): function for function in all_functions_declared} return slither_functions @@ -60,7 +62,7 @@ def _get_slither_functions(slither): def _generate_output(kspec, message, color, generate_json): info = "" for function in kspec: - info += f"{message} {function.contract.name}.{function.full_name}" + info += f"{message} {function.contract.name}.{function.full_name}\n" if info: logger.info(color(info)) @@ -74,7 +76,7 @@ def _generate_output(kspec, message, color, generate_json): def _generate_output_unresolved(kspec, message, color, generate_json): info = "" for contract, function in kspec: - info += f"{message} {contract}.{function}" + info += f"{message} {contract}.{function}\n" if info: logger.info(color(info)) @@ -84,7 +86,6 @@ def _generate_output_unresolved(kspec, message, color, generate_json): return None - def _run_coverage_analysis(args, slither, kspec_functions): # Collect all slither functions slither_functions = _get_slither_functions(slither) @@ -108,7 +109,14 @@ def _run_coverage_analysis(args, slither, kspec_functions): logger.info('## Check for functions coverage') json_kspec_present = _generate_output(kspec_present, "[✓]", green, args.json) - json_kspec_missing = _generate_output(kspec_missing, "[ ] (Missing)", red, args.json) + json_kspec_missing_functions = _generate_output([f for f in kspec_missing if isinstance(f, Function)], + "[ ] (Missing function)", + red, + args.json) + json_kspec_missing_variables = _generate_output([f for f in kspec_missing if isinstance(f, Variable)], + "[ ] (Missing variable)", + yellow, + args.json) json_kspec_unresolved = _generate_output_unresolved(kspec_functions_unresolved, "[ ] (Unresolved)", yellow, @@ -117,14 +125,21 @@ def _run_coverage_analysis(args, slither, kspec_functions): # Handle unresolved kspecs if args.json: json_utils.output_json(args.json, None, { - "kspec_present": json_kspec_present, - "kspec_missing": json_kspec_missing, - "kspec_unresolved": json_kspec_unresolved + "functions_present": json_kspec_present, + "functions_missing": json_kspec_missing_functions, + "variables_missing": json_kspec_missing_variables, + "functions_unresolved": json_kspec_unresolved }) def run_analysis(args, slither, kspec): # Get all of our kspec'd functions (tuple(contract_name, function_name)). - kspec_functions = _get_all_covered_kspec_functions(kspec) + if ',' in kspec: + kspecs = kspec.split(',') + kspec_functions = set() + for kspec in kspecs: + kspec_functions |= _get_all_covered_kspec_functions(kspec) + else: + kspec_functions = _get_all_covered_kspec_functions(kspec) # Run coverage analysis _run_coverage_analysis(args, slither, kspec_functions) diff --git a/slither/tools/kspec_coverage/kspec_coverage.py b/slither/tools/kspec_coverage/kspec_coverage.py index 43434a364..2ee25477f 100755 --- a/slither/tools/kspec_coverage/kspec_coverage.py +++ b/slither/tools/kspec_coverage/kspec_coverage.py @@ -6,7 +6,7 @@ def kspec_coverage(args): contract = args.contract kspec = args.kspec - slither = Slither(contract) + slither = Slither(contract, **vars(args)) # Run the analysis on the Klab specs run_analysis(args, slither, kspec) From b7b85f5d0afea5884f9f3733e9e00e5e13263aaf Mon Sep 17 00:00:00 2001 From: Josselin Date: Wed, 6 Nov 2019 16:34:55 +0100 Subject: [PATCH 218/223] Update travis --- tests/check-kspec/test_1.txt | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/tests/check-kspec/test_1.txt b/tests/check-kspec/test_1.txt index f7334ba30..ed0482c87 100644 --- a/tests/check-kspec/test_1.txt +++ b/tests/check-kspec/test_1.txt @@ -1,4 +1,7 @@ ## Check for functions coverage -[✓] SafeAdd.add(uint256,uint256) -[ ] (Missing) SafeAdd.add_v2(uint256,uint256) -[ ] (Unresolved) SafeAdd.addv2(uint256,uint256) +[✓] SafeAdd.add(uint256,uint256) + +[ ] (Missing function) SafeAdd.add_v2(uint256,uint256) + +[ ] (Unresolved) SafeAdd.addv2(uint256,uint256) + From f70e89bf12c1d5211050ea2b7de7bc785af42778 Mon Sep 17 00:00:00 2001 From: Josselin Date: Tue, 12 Nov 2019 10:19:30 +0100 Subject: [PATCH 219/223] Create utils.output.Output class to handle json output Remove add*_json function --- .../slither_my_plugin/detectors/example.py | 2 +- slither/__main__.py | 4 +- slither/detectors/abstract_detector.py | 72 +-- .../detectors/attributes/const_functions.py | 8 +- .../detectors/attributes/constant_pragma.py | 4 +- .../detectors/attributes/incorrect_solc.py | 2 +- slither/detectors/attributes/locked_ether.py | 2 +- .../erc/incorrect_erc20_interface.py | 2 +- .../erc/incorrect_erc721_interface.py | 4 +- .../erc/unindexed_event_parameters.py | 8 +- slither/detectors/examples/backdoor.py | 4 +- slither/detectors/functions/arbitrary_send.py | 4 +- .../detectors/functions/complex_function.py | 7 +- .../detectors/functions/external_function.py | 4 +- slither/detectors/functions/suicidal.py | 4 +- .../naming_convention/naming_convention.py | 60 +-- .../detectors/operations/block_timestamp.py | 4 +- .../detectors/operations/low_level_calls.py | 4 +- .../operations/unused_return_values.py | 4 +- .../detectors/operations/void_constructor.py | 4 +- .../detectors/reentrancy/reentrancy_benign.py | 12 +- .../detectors/reentrancy/reentrancy_eth.py | 12 +- .../reentrancy_read_before_write.py | 10 +- slither/detectors/shadowing/abstract.py | 4 +- .../detectors/shadowing/builtin_symbols.py | 4 +- slither/detectors/shadowing/local.py | 4 +- slither/detectors/shadowing/state.py | 5 +- slither/detectors/source/rtlo.py | 11 +- slither/detectors/statements/assembly.py | 4 +- slither/detectors/statements/calls_in_loop.py | 4 +- .../statements/controlled_delegatecall.py | 4 +- .../detectors/statements/deprecated_calls.py | 4 +- .../statements/incorrect_strict_equality.py | 4 +- .../detectors/statements/too_many_digits.py | 4 +- slither/detectors/statements/tx_origin.py | 5 +- .../possible_const_state_variables.py | 2 +- .../uninitialized_local_variables.py | 2 +- .../uninitialized_state_variables.py | 2 +- .../uninitialized_storage_variables.py | 2 +- .../variables/unused_state_variables.py | 2 +- slither/printers/abstract_printer.py | 32 +- slither/printers/call/call_graph.py | 6 +- slither/printers/functions/authorization.py | 6 +- slither/printers/functions/cfg.py | 6 +- slither/printers/guidance/echidna.py | 4 +- slither/printers/inheritance/inheritance.py | 4 +- .../printers/inheritance/inheritance_graph.py | 6 +- slither/printers/summary/constructor_calls.py | 83 ++-- slither/printers/summary/contract.py | 15 +- slither/printers/summary/data_depenency.py | 6 +- slither/printers/summary/function.py | 6 +- slither/printers/summary/function_ids.py | 6 +- slither/printers/summary/human_summary.py | 9 +- slither/printers/summary/modifier_calls.py | 6 +- slither/printers/summary/require_calls.py | 6 +- slither/printers/summary/slithir.py | 32 +- slither/printers/summary/slithir_ssa.py | 22 +- slither/printers/summary/variable_order.py | 7 +- slither/slither.py | 2 +- slither/tools/erc_conformance/__main__.py | 6 +- slither/tools/erc_conformance/erc/erc20.py | 8 +- slither/tools/erc_conformance/erc/ercs.py | 57 ++- slither/tools/kspec_coverage/analysis.py | 43 +- slither/tools/upgradeability/__main__.py | 12 +- .../upgradeability/check_initialization.py | 28 +- .../check_variable_initialization.py | 8 +- .../upgradeability/compare_function_ids.py | 32 +- .../upgradeability/compare_variables_order.py | 22 +- .../tools/upgradeability/constant_checks.py | 26 +- slither/utils/json_utils.py | 452 ----------------- slither/utils/output.py | 454 ++++++++++++++++++ 71 files changed, 826 insertions(+), 894 deletions(-) delete mode 100644 slither/utils/json_utils.py create mode 100644 slither/utils/output.py diff --git a/plugin_example/slither_my_plugin/detectors/example.py b/plugin_example/slither_my_plugin/detectors/example.py index ed850d361..5d5a8811e 100644 --- a/plugin_example/slither_my_plugin/detectors/example.py +++ b/plugin_example/slither_my_plugin/detectors/example.py @@ -23,6 +23,6 @@ class Example(AbstractDetector): info = 'This is an example!' - json = self.generate_json_result(info) + json = self.generate_result(info) return [json] diff --git a/slither/__main__.py b/slither/__main__.py index 699134c58..e982b8cde 100644 --- a/slither/__main__.py +++ b/slither/__main__.py @@ -19,7 +19,7 @@ from slither.detectors.abstract_detector import (AbstractDetector, from slither.printers import all_printers from slither.printers.abstract_printer import AbstractPrinter from slither.slither import Slither -from slither.utils.json_utils import output_json +from slither.utils.output import output_to_json from slither.utils.output_capture import StandardOutputCapture from slither.utils.colors import red, yellow, set_colorization_enabled from slither.utils.command_line import (output_detectors, output_results_to_markdown, @@ -638,7 +638,7 @@ def main_impl(all_detector_classes, all_printer_classes): 'stderr': StandardOutputCapture.get_stderr_output() } StandardOutputCapture.disable() - output_json(None if outputting_json_stdout else args.json, output_error, json_results) + output_to_json(None if outputting_json_stdout else args.json, output_error, json_results) # Exit with the appropriate status code if output_error: diff --git a/slither/detectors/abstract_detector.py b/slither/detectors/abstract_detector.py index 06a6ae8fa..765b79d15 100644 --- a/slither/detectors/abstract_detector.py +++ b/slither/detectors/abstract_detector.py @@ -4,7 +4,7 @@ import re from slither.utils.colors import green, yellow, red from slither.formatters.exceptions import FormatImpossible from slither.formatters.utils.patches import apply_patch, create_diff -from slither.utils import json_utils +from slither.utils.output import Output class IncorrectDetectorInitialization(Exception): @@ -103,10 +103,12 @@ class AbstractDetector(metaclass=abc.ABCMeta): @abc.abstractmethod def _detect(self): """TODO Documentation""" - return + return [] def detect(self): all_results = self._detect() + # Keep only dictionaries + all_results = [r.data for r in all_results] results = [] # only keep valid result, and remove dupplicate [results.append(r) for r in all_results if self.slither.valid_result(r) and r not in results] @@ -170,65 +172,17 @@ class AbstractDetector(metaclass=abc.ABCMeta): def color(self): return classification_colors[self.IMPACT] - def generate_json_result(self, info, additional_fields=None): - d = json_utils.generate_json_result(info, - additional_fields, - standard_format=self.STANDARD_JSON, - markdown_root=self.slither.markdown_root) + def generate_result(self, info, additional_fields=None): + output = Output(info, + additional_fields, + standard_format=self.STANDARD_JSON, + markdown_root=self.slither.markdown_root) - d['check'] = self.ARGUMENT - d['impact'] = classification_txt[self.IMPACT] - d['confidence'] = classification_txt[self.CONFIDENCE] + output.data['check'] = self.ARGUMENT + output.data['impact'] = classification_txt[self.IMPACT] + output.data['confidence'] = classification_txt[self.CONFIDENCE] - return d - - @staticmethod - def add_variable_to_json(e, d, additional_fields=None): - json_utils.add_variable_to_json(e, d, additional_fields=additional_fields) - - @staticmethod - def add_variables_to_json(e, d): - json_utils.add_variables_to_json(e, d) - - @staticmethod - def add_contract_to_json(e, d, additional_fields=None): - json_utils.add_contract_to_json(e, d, additional_fields=additional_fields) - - @staticmethod - def add_function_to_json(e, d, additional_fields=None): - json_utils.add_function_to_json(e, d, additional_fields=additional_fields) - - @staticmethod - def add_functions_to_json(e, d, additional_fields=None): - json_utils.add_functions_to_json(e, d, additional_fields=additional_fields) - - @staticmethod - def add_enum_to_json(e, d, additional_fields=None): - json_utils.add_enum_to_json(e, d, additional_fields=additional_fields) - - @staticmethod - def add_struct_to_json(e, d, additional_fields=None): - json_utils.add_struct_to_json(e, d, additional_fields=additional_fields) - - @staticmethod - def add_event_to_json(e, d, additional_fields=None): - json_utils.add_event_to_json(e, d, additional_fields=additional_fields) - - @staticmethod - def add_pragma_to_json(e, d, additional_fields=None): - json_utils.add_pragma_to_json(e, d, additional_fields=additional_fields) - - @staticmethod - def add_node_to_json(e, d, additional_fields=None): - json_utils.add_node_to_json(e, d, additional_fields=additional_fields) - - @staticmethod - def add_nodes_to_json(e, d): - json_utils.add_nodes_to_json(e, d) - - @staticmethod - def add_other_to_json(name, source_mapping, d, slither, additional_fields=None): - json_utils.add_other_to_json(name, source_mapping, d, slither, additional_fields=additional_fields) + return output @staticmethod def _format(slither, result): diff --git a/slither/detectors/attributes/const_functions.py b/slither/detectors/attributes/const_functions.py index 99247b91b..6e892a626 100644 --- a/slither/detectors/attributes/const_functions.py +++ b/slither/detectors/attributes/const_functions.py @@ -59,9 +59,9 @@ All the calls to `get` revert, breaking Bob's smart contract execution.''' attr = 'view' if f.view else 'pure' info = [f, f' is declared {attr} but contains assembly code\n'] - json = self.generate_json_result(info, {'contains_assembly': True}) + res = self.generate_result(info, {'contains_assembly': True}) - results.append(json) + results.append(res) variables_written = f.all_state_variables_written() if variables_written: @@ -72,9 +72,9 @@ All the calls to `get` revert, breaking Bob's smart contract execution.''' for variable_written in variables_written: info += ['\t- ', variable_written, '\n'] - json = self.generate_json_result(info, {'contains_assembly': False}) + res = self.generate_result(info, {'contains_assembly': False}) - results.append(json) + results.append(res) return results diff --git a/slither/detectors/attributes/constant_pragma.py b/slither/detectors/attributes/constant_pragma.py index d931d6a3d..b7d593357 100644 --- a/slither/detectors/attributes/constant_pragma.py +++ b/slither/detectors/attributes/constant_pragma.py @@ -36,9 +36,9 @@ class ConstantPragma(AbstractDetector): for p in pragma: info += ["\t- ", p, "\n"] - json = self.generate_json_result(info) + res = self.generate_result(info) - results.append(json) + results.append(res) return results diff --git a/slither/detectors/attributes/incorrect_solc.py b/slither/detectors/attributes/incorrect_solc.py index 6a48bc3c7..f63a2bdf2 100644 --- a/slither/detectors/attributes/incorrect_solc.py +++ b/slither/detectors/attributes/incorrect_solc.py @@ -102,7 +102,7 @@ Use Solidity 0.4.25 or 0.5.3. Consider using the latest version of Solidity for for (reason, p) in disallowed_pragmas: info = ["Pragma version", p, f" {reason}\n"] - json = self.generate_json_result(info) + json = self.generate_result(info) results.append(json) diff --git a/slither/detectors/attributes/locked_ether.py b/slither/detectors/attributes/locked_ether.py index 3de56c00c..97ffb0db2 100644 --- a/slither/detectors/attributes/locked_ether.py +++ b/slither/detectors/attributes/locked_ether.py @@ -80,7 +80,7 @@ Every ether sent to `Locked` will be lost.''' info += [f"\t - ", function, "\n"] info += "\tBut does not have a function to withdraw the ether\n" - json = self.generate_json_result(info) + json = self.generate_result(info) results.append(json) diff --git a/slither/detectors/erc/incorrect_erc20_interface.py b/slither/detectors/erc/incorrect_erc20_interface.py index a9aa4ad77..b7782a66a 100644 --- a/slither/detectors/erc/incorrect_erc20_interface.py +++ b/slither/detectors/erc/incorrect_erc20_interface.py @@ -88,7 +88,7 @@ contract Token{ if functions: for function in functions: info = [c, " has incorrect ERC20 function interface:", function, "\n"] - json = self.generate_json_result(info) + json = self.generate_result(info) results.append(json) diff --git a/slither/detectors/erc/incorrect_erc721_interface.py b/slither/detectors/erc/incorrect_erc721_interface.py index bce1695b1..e6a484631 100644 --- a/slither/detectors/erc/incorrect_erc721_interface.py +++ b/slither/detectors/erc/incorrect_erc721_interface.py @@ -87,8 +87,8 @@ contract Token{ if functions: for function in functions: info = [c, " has incorrect ERC721 function interface:", function, "\n"] - json = self.generate_json_result(info) + res = self.generate_result(info) - results.append(json) + results.append(res) return results diff --git a/slither/detectors/erc/unindexed_event_parameters.py b/slither/detectors/erc/unindexed_event_parameters.py index 1e382da59..096c63f16 100644 --- a/slither/detectors/erc/unindexed_event_parameters.py +++ b/slither/detectors/erc/unindexed_event_parameters.py @@ -76,12 +76,10 @@ In this case, Transfer and Approval events should have the 'indexed' keyword on info = ["ERC20 event ", event, f"does not index parameter {parameter}\n"] # Add the events to the JSON (note: we do not add the params/vars as they have no source mapping). - json = self.generate_json_result(info) + res = self.generate_result(info) - self.add_event_to_json(event, json, { - "parameter_name": parameter.name - }) - results.append(json) + res.add(event, {"parameter_name": parameter.name}) + results.append(res) return results diff --git a/slither/detectors/examples/backdoor.py b/slither/detectors/examples/backdoor.py index d9f00979e..76511d018 100644 --- a/slither/detectors/examples/backdoor.py +++ b/slither/detectors/examples/backdoor.py @@ -29,8 +29,8 @@ class Backdoor(AbstractDetector): info = ['Backdoor function found in ', f, '\n'] # Add the result in result - json = self.generate_json_result(info) + res = self.generate_result(info) - results.append(json) + results.append(res) return results diff --git a/slither/detectors/functions/arbitrary_send.py b/slither/detectors/functions/arbitrary_send.py index 4a14873a9..2c608e73a 100644 --- a/slither/detectors/functions/arbitrary_send.py +++ b/slither/detectors/functions/arbitrary_send.py @@ -114,8 +114,8 @@ Bob calls `setDestination` and `withdraw`. As a result he withdraws the contract for node in nodes: info += ['\t- ', node, '\n'] - json = self.generate_json_result(info) + res = self.generate_result(info) - results.append(json) + results.append(res) return results diff --git a/slither/detectors/functions/complex_function.py b/slither/detectors/functions/complex_function.py index fae9a0923..21add9239 100644 --- a/slither/detectors/functions/complex_function.py +++ b/slither/detectors/functions/complex_function.py @@ -31,6 +31,7 @@ class ComplexFunction(AbstractDetector): CAUSE_EXTERNAL_CALL = "external_calls" CAUSE_STATE_VARS = "state_vars" + STANDARD_JSON = True @staticmethod def detect_complex_func(func): @@ -104,14 +105,14 @@ class ComplexFunction(AbstractDetector): info = info + "\n" self.log(info) - json = self.generate_json_result(info) - self.add_function_to_json(func, json, { + res = self.generate_result(info) + res.add(func, { 'high_number_of_external_calls': cause == self.CAUSE_EXTERNAL_CALL, 'high_number_of_branches': cause == self.CAUSE_CYCLOMATIC, 'high_number_of_state_variables': cause == self.CAUSE_STATE_VARS }) - results.append(json) + results.append(res) return results diff --git a/slither/detectors/functions/external_function.py b/slither/detectors/functions/external_function.py index 7b48be5ba..f5d9aad61 100644 --- a/slither/detectors/functions/external_function.py +++ b/slither/detectors/functions/external_function.py @@ -187,9 +187,9 @@ class ExternalFunction(AbstractDetector): for other_function_definition in all_function_definitions: info += [f"\t- ", other_function_definition, "\n"] - json = self.generate_json_result(info) + res = self.generate_result(info) - results.append(json) + results.append(res) return results diff --git a/slither/detectors/functions/suicidal.py b/slither/detectors/functions/suicidal.py index 2dc28cf13..a3599fcad 100644 --- a/slither/detectors/functions/suicidal.py +++ b/slither/detectors/functions/suicidal.py @@ -75,8 +75,8 @@ Bob calls `kill` and destructs the contract.''' info = [func, " allows anyone to destruct the contract\n"] - json = self.generate_json_result(info) + res = self.generate_result(info) - results.append(json) + results.append(res) return results diff --git a/slither/detectors/naming_convention/naming_convention.py b/slither/detectors/naming_convention/naming_convention.py index 93825e419..3f07d1cba 100644 --- a/slither/detectors/naming_convention/naming_convention.py +++ b/slither/detectors/naming_convention/naming_convention.py @@ -62,34 +62,34 @@ Solidity defines a [naming convention](https://solidity.readthedocs.io/en/v0.4.2 if not self.is_cap_words(contract.name): info = ["Contract ", contract, " is not in CapWords\n"] - json = self.generate_json_result(info) - self.add_contract_to_json(contract, json, { + res = self.generate_result(info) + res.add(contract, { "target": "contract", "convention": "CapWords" }) - results.append(json) + results.append(res) for struct in contract.structures_declared: if not self.is_cap_words(struct.name): info = ["Struct ", struct, " is not in CapWords\n"] - json = self.generate_json_result(info) - self.add_struct_to_json(struct, json, { + res = self.generate_result(info) + res.add(struct, { "target": "structure", "convention": "CapWords" }) - results.append(json) + results.append(res) for event in contract.events_declared: if not self.is_cap_words(event.name): info = ["Event ", event, " is not in CapWords\n"] - json = self.generate_json_result(info) - self.add_event_to_json(event, json, { + res = self.generate_result(info) + res.add(event, { "target": "event", "convention": "CapWords" }) - results.append(json) + results.append(res) for func in contract.functions_declared: if func.is_constructor: @@ -101,12 +101,12 @@ Solidity defines a [naming convention](https://solidity.readthedocs.io/en/v0.4.2 continue info = ["Function ", func, " is not in mixedCase\n"] - json = self.generate_json_result(info) - self.add_function_to_json(func, json, { + res = self.generate_result(info) + res.add(func, { "target": "function", "convention": "mixedCase" }) - results.append(json) + results.append(res) for argument in func.parameters: # Ignore parameter names that are not specified i.e. empty strings @@ -119,24 +119,24 @@ Solidity defines a [naming convention](https://solidity.readthedocs.io/en/v0.4.2 if not correct_naming: info = ["Parameter ", argument, " is not in mixedCase\n"] - json = self.generate_json_result(info) - self.add_variable_to_json(argument, json, { + res = self.generate_result(info) + res.add(argument, { "target": "parameter", "convention": "mixedCase" }) - results.append(json) + results.append(res) for var in contract.state_variables_declared: if self.should_avoid_name(var.name): if not self.is_upper_case_with_underscores(var.name): info = ["Variable ", var," used l, O, I, which should not be used\n"] - json = self.generate_json_result(info) - self.add_variable_to_json(var, json, { + res = self.generate_result(info) + res.add(var, { "target": "variable", "convention": "l_O_I_should_not_be_used" }) - results.append(json) + results.append(res) if var.is_constant is True: # For ERC20 compatibility @@ -146,12 +146,12 @@ Solidity defines a [naming convention](https://solidity.readthedocs.io/en/v0.4.2 if not self.is_upper_case_with_underscores(var.name): info = ["Constant ", var," is not in UPPER_CASE_WITH_UNDERSCORES\n"] - json = self.generate_json_result(info) - self.add_variable_to_json(var, json, { + res = self.generate_result(info) + res.add(var, { "target": "variable_constant", "convention": "UPPER_CASE_WITH_UNDERSCORES" }) - results.append(json) + results.append(res) else: if var.visibility == 'private': @@ -161,34 +161,34 @@ Solidity defines a [naming convention](https://solidity.readthedocs.io/en/v0.4.2 if not correct_naming: info = ["Variable ", var, " is not in mixedCase\n"] - json = self.generate_json_result(info) - self.add_variable_to_json(var, json, { + res = self.generate_result(info) + res.add(var, { "target": "variable", "convention": "mixedCase" }) - results.append(json) + results.append(res) for enum in contract.enums_declared: if not self.is_cap_words(enum.name): info = ["Enum ", enum, " is not in CapWords\n"] - json = self.generate_json_result(info) - self.add_enum_to_json(enum, json, { + res = self.generate_result(info) + res.add(enum, { "target": "enum", "convention": "CapWords" }) - results.append(json) + results.append(res) for modifier in contract.modifiers_declared: if not self.is_mixed_case(modifier.name): info = ["Modifier ", modifier, " is not in mixedCase\n"] - json = self.generate_json_result(info) - self.add_function_to_json(modifier, json, { + res = self.generate_result(info) + res.add(modifier, { "target": "modifier", "convention": "mixedCase" }) - results.append(json) + results.append(res) return results diff --git a/slither/detectors/operations/block_timestamp.py b/slither/detectors/operations/block_timestamp.py index 23ad8e178..6dc76ae50 100644 --- a/slither/detectors/operations/block_timestamp.py +++ b/slither/detectors/operations/block_timestamp.py @@ -75,8 +75,8 @@ class Timestamp(AbstractDetector): for node in nodes: info += ['\t- ', node, '\n'] - json = self.generate_json_result(info) + res = self.generate_result(info) - results.append(json) + results.append(res) return results diff --git a/slither/detectors/operations/low_level_calls.py b/slither/detectors/operations/low_level_calls.py index c22ff8139..1a46a9909 100644 --- a/slither/detectors/operations/low_level_calls.py +++ b/slither/detectors/operations/low_level_calls.py @@ -53,8 +53,8 @@ class LowLevelCalls(AbstractDetector): for node in nodes: info += ['\t- ', node, '\n'] - json = self.generate_json_result(info) + res = self.generate_result(info) - results.append(json) + results.append(res) return results diff --git a/slither/detectors/operations/unused_return_values.py b/slither/detectors/operations/unused_return_values.py index a8233a6d8..b1e2b6d08 100644 --- a/slither/detectors/operations/unused_return_values.py +++ b/slither/detectors/operations/unused_return_values.py @@ -76,9 +76,9 @@ contract MyConc{ for node in unused_return: info = [f, f" ignores return value by ", node, "\n"] - json = self.generate_json_result(info) + res = self.generate_result(info) - results.append(json) + results.append(res) return results diff --git a/slither/detectors/operations/void_constructor.py b/slither/detectors/operations/void_constructor.py index 181a5ae50..74abd1329 100644 --- a/slither/detectors/operations/void_constructor.py +++ b/slither/detectors/operations/void_constructor.py @@ -39,7 +39,7 @@ By reading B's constructor definition, the reader might assume that `A()` initia info = ["Void constructor called in ", cst, ":\n"] info += ["\t- ", node, "\n"] - json = self.generate_json_result(info) + res = self.generate_result(info) - results.append(json) + results.append(res) return results diff --git a/slither/detectors/reentrancy/reentrancy_benign.py b/slither/detectors/reentrancy/reentrancy_benign.py index 79dfec78f..2ff6e8475 100644 --- a/slither/detectors/reentrancy/reentrancy_benign.py +++ b/slither/detectors/reentrancy/reentrancy_benign.py @@ -95,14 +95,14 @@ Only report reentrancy that acts as a double call (see `reentrancy-eth`, `reentr # Create our JSON result - json = self.generate_json_result(info) + res = self.generate_result(info) # Add the function with the re-entrancy first - self.add_function_to_json(func, json) + res.add(func) # Add all underlying calls in the function which are potentially problematic. for call_info in calls: - self.add_node_to_json(call_info, json, { + res.add(call_info, { "underlying_type": "external_calls" }) @@ -111,18 +111,18 @@ Only report reentrancy that acts as a double call (see `reentrancy-eth`, `reentr # If the calls are not the same ones that send eth, add the eth sending nodes. if calls != send_eth: for call_info in send_eth: - self.add_node_to_json(call_info, json, { + res.add(call_info, { "underlying_type": "external_calls_sending_eth" }) # Add all variables written via nodes which write them. for (v, node) in varsWritten: - self.add_node_to_json(node, json, { + res.add(node, { "underlying_type": "variables_written", "variable_name": v.name }) # Append our result - results.append(json) + results.append(res) return results diff --git a/slither/detectors/reentrancy/reentrancy_eth.py b/slither/detectors/reentrancy/reentrancy_eth.py index b0d501ec1..a5f0c0365 100644 --- a/slither/detectors/reentrancy/reentrancy_eth.py +++ b/slither/detectors/reentrancy/reentrancy_eth.py @@ -95,14 +95,14 @@ Bob uses the re-entrancy bug to call `withdrawBalance` two times, and withdraw m info += ['\t- ', v, ' in ', node, '\n'] # Create our JSON result - json = self.generate_json_result(info) + res = self.generate_result(info) # Add the function with the re-entrancy first - self.add_function_to_json(func, json) + res.add(func) # Add all underlying calls in the function which are potentially problematic. for call_info in calls: - self.add_node_to_json(call_info, json, { + res.add(call_info, { "underlying_type": "external_calls" }) @@ -111,18 +111,18 @@ Bob uses the re-entrancy bug to call `withdrawBalance` two times, and withdraw m # If the calls are not the same ones that send eth, add the eth sending nodes. if calls != send_eth: for call_info in send_eth: - self.add_node_to_json(call_info, json, { + res.add(call_info, { "underlying_type": "external_calls_sending_eth" }) # Add all variables written via nodes which write them. for (v, node) in varsWritten: - self.add_node_to_json(node, json, { + res.add(node, { "underlying_type": "variables_written", "variable_name": v.name }) # Append our result - results.append(json) + results.append(res) return results diff --git a/slither/detectors/reentrancy/reentrancy_read_before_write.py b/slither/detectors/reentrancy/reentrancy_read_before_write.py index 6389847fc..f28b5b615 100644 --- a/slither/detectors/reentrancy/reentrancy_read_before_write.py +++ b/slither/detectors/reentrancy/reentrancy_read_before_write.py @@ -88,25 +88,25 @@ Do not report reentrancies that involve ethers (see `reentrancy-eth`)''' info += ['\t- ', v, ' in ', node, '\n'] # Create our JSON result - json = self.generate_json_result(info) + res = self.generate_result(info) # Add the function with the re-entrancy first - self.add_function_to_json(func, json) + res.add(func) # Add all underlying calls in the function which are potentially problematic. for call_info in calls: - self.add_node_to_json(call_info, json, { + res.add(call_info, { "underlying_type": "external_calls" }) # Add all variables written via nodes which write them. for (v, node) in varsWritten: - self.add_node_to_json(node, json, { + res.add(node, { "underlying_type": "variables_written", "variable_name": v.name }) # Append our result - results.append(json) + results.append(res) return results diff --git a/slither/detectors/shadowing/abstract.py b/slither/detectors/shadowing/abstract.py index f2e7c7119..d882a09a3 100644 --- a/slither/detectors/shadowing/abstract.py +++ b/slither/detectors/shadowing/abstract.py @@ -69,8 +69,8 @@ contract DerivedContract is BaseContract{ for var in variables: info += ["\t- ", var, "\n"] - json = self.generate_json_result(info) + res = self.generate_result(info) - results.append(json) + results.append(res) return results diff --git a/slither/detectors/shadowing/builtin_symbols.py b/slither/detectors/shadowing/builtin_symbols.py index c0bf4e8b0..1af228c5a 100644 --- a/slither/detectors/shadowing/builtin_symbols.py +++ b/slither/detectors/shadowing/builtin_symbols.py @@ -127,7 +127,7 @@ contract Bug { info = [shadow_object, f' ({shadow_type}) shadows built-in symbol"\n'] - json = self.generate_json_result(info) - results.append(json) + res = self.generate_result(info) + results.append(res) return results diff --git a/slither/detectors/shadowing/local.py b/slither/detectors/shadowing/local.py index 0da45cf99..7f00f495d 100644 --- a/slither/detectors/shadowing/local.py +++ b/slither/detectors/shadowing/local.py @@ -109,8 +109,8 @@ contract Bug { info += ["\t- ", overshadowed_entry[1], f" ({overshadowed_entry[0]})\n"] # Generate relevant JSON data for this shadowing definition. - json = self.generate_json_result(info) + res = self.generate_result(info) - results.append(json) + results.append(res) return results diff --git a/slither/detectors/shadowing/state.py b/slither/detectors/shadowing/state.py index b5df61151..81421cd2d 100644 --- a/slither/detectors/shadowing/state.py +++ b/slither/detectors/shadowing/state.py @@ -80,9 +80,8 @@ contract DerivedContract is BaseContract{ for var in variables: info += ["\t- ", var, "\n"] - json = self.generate_json_result(info) - - results.append(json) + res = self.generate_result(info) + results.append(res) return results diff --git a/slither/detectors/source/rtlo.py b/slither/detectors/source/rtlo.py index 135b5aa6a..d69201334 100644 --- a/slither/detectors/source/rtlo.py +++ b/slither/detectors/source/rtlo.py @@ -73,12 +73,11 @@ contract Token # We have a patch, so pattern.find will return at least one result info += f"\t- {pattern.findall(source_encoded)[0]}\n" - json = self.generate_json_result(info) - self.add_other_to_json("rtlo-character", - (filename, idx, len(self.RTLO_CHARACTER_ENCODED)), - json, - self.slither) - results.append(json) + res = self.generate_result(info) + res.add_other("rtlo-character", + (filename, idx, len(self.RTLO_CHARACTER_ENCODED)), + self.slither) + results.append(res) # Advance the start index for the next iteration start_index = result_index + 1 diff --git a/slither/detectors/statements/assembly.py b/slither/detectors/statements/assembly.py index af65f2331..bf84dab7a 100644 --- a/slither/detectors/statements/assembly.py +++ b/slither/detectors/statements/assembly.py @@ -56,7 +56,7 @@ class Assembly(AbstractDetector): for node in nodes: info += ["\t- ", node, "\n"] - json = self.generate_json_result(info) - results.append(json) + res = self.generate_result(info) + results.append(res) return results diff --git a/slither/detectors/statements/calls_in_loop.py b/slither/detectors/statements/calls_in_loop.py index b2dfd5c11..cf115c858 100644 --- a/slither/detectors/statements/calls_in_loop.py +++ b/slither/detectors/statements/calls_in_loop.py @@ -88,7 +88,7 @@ If one of the destinations has a fallback function which reverts, `bad` will alw func = node.function info = [func, " has external calls inside a loop: ", node, "\n"] - json = self.generate_json_result(info) - results.append(json) + res = self.generate_result(info) + results.append(res) return results diff --git a/slither/detectors/statements/controlled_delegatecall.py b/slither/detectors/statements/controlled_delegatecall.py index 0dcff87bc..987757847 100644 --- a/slither/detectors/statements/controlled_delegatecall.py +++ b/slither/detectors/statements/controlled_delegatecall.py @@ -51,7 +51,7 @@ Bob calls `delegate` and delegates the execution to its malicious contract. As a for node in nodes: node_info = func_info + ['\t- ', node,'\n'] - json = self.generate_json_result(node_info) - results.append(json) + res = self.generate_result(node_info) + results.append(res) return results diff --git a/slither/detectors/statements/deprecated_calls.py b/slither/detectors/statements/deprecated_calls.py index de8b8e860..b56a807c5 100644 --- a/slither/detectors/statements/deprecated_calls.py +++ b/slither/detectors/statements/deprecated_calls.py @@ -157,7 +157,7 @@ contract ContractWithDeprecatedReferences { for (dep_id, original_desc, recommended_disc) in deprecated_entries: info += [f"\t- Usage of \"{original_desc}\" should be replaced with \"{recommended_disc}\"\n"] - json = self.generate_json_result(info) - results.append(json) + res = self.generate_result(info) + results.append(res) return results diff --git a/slither/detectors/statements/incorrect_strict_equality.py b/slither/detectors/statements/incorrect_strict_equality.py index 01faf4d62..b0b47d025 100644 --- a/slither/detectors/statements/incorrect_strict_equality.py +++ b/slither/detectors/statements/incorrect_strict_equality.py @@ -120,7 +120,7 @@ contract Crowdsale{ for node in nodes: node_info = func_info + [f"\t- ", node, "\n"] - json = self.generate_json_result(node_info) - results.append(json) + res = self.generate_result(node_info) + results.append(res) return results diff --git a/slither/detectors/statements/too_many_digits.py b/slither/detectors/statements/too_many_digits.py index 0e6591546..32d4ab93c 100644 --- a/slither/detectors/statements/too_many_digits.py +++ b/slither/detectors/statements/too_many_digits.py @@ -69,7 +69,7 @@ Use: node_info = func_info + ['\n\t- ', node,'\n'] # Add the result in result - json = self.generate_json_result(node_info) - results.append(json) + res = self.generate_result(node_info) + results.append(res) return results diff --git a/slither/detectors/statements/tx_origin.py b/slither/detectors/statements/tx_origin.py index 8f2b9968b..adc274b10 100644 --- a/slither/detectors/statements/tx_origin.py +++ b/slither/detectors/statements/tx_origin.py @@ -69,8 +69,7 @@ Bob is the owner of `TxOrigin`. Bob calls Eve's contract. Eve's contract calls ` for node in nodes: info = [func, " uses tx.origin for authorization: ", node, "\n"] - json = self.generate_json_result(info) - - results.append(json) + res = self.generate_result(info) + results.append(res) return results diff --git a/slither/detectors/variables/possible_const_state_variables.py b/slither/detectors/variables/possible_const_state_variables.py index eaed2dac8..2d6d40b06 100644 --- a/slither/detectors/variables/possible_const_state_variables.py +++ b/slither/detectors/variables/possible_const_state_variables.py @@ -89,7 +89,7 @@ class ConstCandidateStateVars(AbstractDetector): # Create a result for each finding for v in constable_variables: info = [v, " should be constant\n"] - json = self.generate_json_result(info) + json = self.generate_result(info) results.append(json) return results diff --git a/slither/detectors/variables/uninitialized_local_variables.py b/slither/detectors/variables/uninitialized_local_variables.py index cc0ff0968..09d185208 100644 --- a/slither/detectors/variables/uninitialized_local_variables.py +++ b/slither/detectors/variables/uninitialized_local_variables.py @@ -99,7 +99,7 @@ Bob calls `transfer`. As a result, the ethers are sent to the address 0x0 and ar for(function, uninitialized_local_variable) in all_results: info = [uninitialized_local_variable, " is a local variable never initialiazed\n"] - json = self.generate_json_result(info) + json = self.generate_result(info) results.append(json) return results diff --git a/slither/detectors/variables/uninitialized_state_variables.py b/slither/detectors/variables/uninitialized_state_variables.py index 8eaa784e6..795d74e39 100644 --- a/slither/detectors/variables/uninitialized_state_variables.py +++ b/slither/detectors/variables/uninitialized_state_variables.py @@ -93,7 +93,7 @@ Initialize all the variables. If a variable is meant to be initialized to zero, for f in functions: info += ["\t- ", f, "\n"] - json = self.generate_json_result(info) + json = self.generate_result(info) results.append(json) return results diff --git a/slither/detectors/variables/uninitialized_storage_variables.py b/slither/detectors/variables/uninitialized_storage_variables.py index f77f95d2a..7efa3391b 100644 --- a/slither/detectors/variables/uninitialized_storage_variables.py +++ b/slither/detectors/variables/uninitialized_storage_variables.py @@ -102,7 +102,7 @@ Bob calls `func`. As a result, `owner` is override to 0. for(function, uninitialized_storage_variable) in self.results: info = [uninitialized_storage_variable, " is a storage variable never initialiazed\n"] - json = self.generate_json_result(info) + json = self.generate_result(info) results.append(json) return results diff --git a/slither/detectors/variables/unused_state_variables.py b/slither/detectors/variables/unused_state_variables.py index def3d2804..d1b4f2179 100644 --- a/slither/detectors/variables/unused_state_variables.py +++ b/slither/detectors/variables/unused_state_variables.py @@ -61,7 +61,7 @@ class UnusedStateVars(AbstractDetector): if unusedVars: for var in unusedVars: info = [var, " is never used in ", c, "\n"] - json = self.generate_json_result(info) + json = self.generate_result(info) results.append(json) return results diff --git a/slither/printers/abstract_printer.py b/slither/printers/abstract_printer.py index 3c7331138..ceaa75d5d 100644 --- a/slither/printers/abstract_printer.py +++ b/slither/printers/abstract_printer.py @@ -1,6 +1,6 @@ import abc -from slither.utils import json_utils +from slither.utils import output class IncorrectPrinterInitialization(Exception): @@ -33,38 +33,14 @@ class AbstractPrinter(metaclass=abc.ABCMeta): self.logger.info(info) - def generate_json_result(self, info, additional_fields=None): + def generate_output(self, info, additional_fields=None): if additional_fields is None: additional_fields = {} - d = json_utils.generate_json_result(info, additional_fields) - d['printer'] = self.ARGUMENT + d = output.Output(info, additional_fields) + d.data['printer'] = self.ARGUMENT return d - @staticmethod - def add_contract_to_json(e, d, additional_fields=None): - json_utils.add_contract_to_json(e, d, additional_fields=additional_fields) - - @staticmethod - def add_function_to_json(e, d, additional_fields=None): - json_utils.add_function_to_json(e, d, additional_fields=additional_fields) - - @staticmethod - def add_functions_to_json(e, d, additional_fields=None): - json_utils.add_functions_to_json(e, d, additional_fields=additional_fields) - - @staticmethod - def add_file_to_json(e, content, d, additional_fields=None): - json_utils.add_file_to_json(e, content, d, additional_fields) - - @staticmethod - def add_pretty_table_to_json(e, content, d, additional_fields=None): - json_utils.add_pretty_table_to_json(e, content, d, additional_fields) - - @staticmethod - def add_other_to_json(name, source_mapping, d, slither, additional_fields=None): - json_utils.add_other_to_json(name, source_mapping, d, slither, additional_fields) - @abc.abstractmethod def output(self, filename): """TODO Documentation""" diff --git a/slither/printers/call/call_graph.py b/slither/printers/call/call_graph.py index 2f224ece0..8710e82ed 100644 --- a/slither/printers/call/call_graph.py +++ b/slither/printers/call/call_graph.py @@ -176,9 +176,9 @@ class PrinterCallGraph(AbstractPrinter): results.append((filename, content)) self.info(info) - json = self.generate_json_result(info) + res = self.generate_output(info) for filename, content in results: - self.add_file_to_json(filename, content, json) + res.add_file(filename, content) - return json + return res diff --git a/slither/printers/functions/authorization.py b/slither/printers/functions/authorization.py index 72fc532b3..24f606f1a 100644 --- a/slither/printers/functions/authorization.py +++ b/slither/printers/functions/authorization.py @@ -48,8 +48,8 @@ class PrinterWrittenVariablesAndAuthorization(AbstractPrinter): txt += str(table) + '\n' self.info(txt) - json = self.generate_json_result(txt) + res = self.generate_output(txt) for name, table in all_tables: - self.add_pretty_table_to_json(table, name, json) + res.add_pretty_table(table, name) - return json \ No newline at end of file + return res \ No newline at end of file diff --git a/slither/printers/functions/cfg.py b/slither/printers/functions/cfg.py index 191d63b5c..a8b53a3be 100644 --- a/slither/printers/functions/cfg.py +++ b/slither/printers/functions/cfg.py @@ -31,7 +31,7 @@ class CFG(AbstractPrinter): self.info(info) - json = self.generate_json_result(info) + res = self.generate_output(info) for filename, content in all_files: - self.add_file_to_json(filename, content, json) - return json \ No newline at end of file + res.add_file(filename, content) + return res \ No newline at end of file diff --git a/slither/printers/guidance/echidna.py b/slither/printers/guidance/echidna.py index f2034aa17..ab17cd15b 100644 --- a/slither/printers/guidance/echidna.py +++ b/slither/printers/guidance/echidna.py @@ -140,4 +140,6 @@ class Echidna(AbstractPrinter): self.info(json.dumps(d, indent=4)) - return d \ No newline at end of file + res = self.generate_output(json.dumps(d, indent=4)) + + return res \ No newline at end of file diff --git a/slither/printers/inheritance/inheritance.py b/slither/printers/inheritance/inheritance.py index f3b970dfc..e6b2972fb 100644 --- a/slither/printers/inheritance/inheritance.py +++ b/slither/printers/inheritance/inheritance.py @@ -75,6 +75,6 @@ class PrinterInheritance(AbstractPrinter): result['base_to_child'][base.name]['not_immediate'] = list(map(str, immediate)) self.info(info) - json = self.generate_json_result(info, additional_fields=result) + res = self.generate_output(info, additional_fields=result) - return json + return res diff --git a/slither/printers/inheritance/inheritance_graph.py b/slither/printers/inheritance/inheritance_graph.py index 52f4f32e2..de527809a 100644 --- a/slither/printers/inheritance/inheritance_graph.py +++ b/slither/printers/inheritance/inheritance_graph.py @@ -172,7 +172,7 @@ class PrinterInheritanceGraph(AbstractPrinter): with open(filename, 'w', encoding='utf8') as f: f.write(content) - json = self.generate_json_result(info) - self.add_file_to_json(filename, content, json) + res = self.generate_output(info) + res.add_file(filename, content) - return json \ No newline at end of file + return res \ No newline at end of file diff --git a/slither/printers/summary/constructor_calls.py b/slither/printers/summary/constructor_calls.py index d0edb93be..aae307827 100644 --- a/slither/printers/summary/constructor_calls.py +++ b/slither/printers/summary/constructor_calls.py @@ -2,46 +2,51 @@ Module printing summary of the contract """ from slither.printers.abstract_printer import AbstractPrinter - +from slither.utils import output class ConstructorPrinter(AbstractPrinter): - WIKI = 'https://github.com/crytic/slither/wiki/Printer-documentation#constructor-calls' - ARGUMENT = 'constructor-calls' - HELP = 'Print the constructors executed' - - def _get_soruce_code(self,cst): - src_mapping = cst.source_mapping - content= self.slither.source_code[src_mapping['filename_absolute']] - start = src_mapping['start'] - end = src_mapping['start'] + src_mapping['length'] - initial_space = src_mapping['starting_column'] - return ' ' * initial_space + content[start:end] + WIKI = 'https://github.com/crytic/slither/wiki/Printer-documentation#constructor-calls' + ARGUMENT = 'constructor-calls' + HELP = 'Print the constructors executed' + + def _get_soruce_code(self, cst): + src_mapping = cst.source_mapping + content = self.slither.source_code[src_mapping['filename_absolute']] + start = src_mapping['start'] + end = src_mapping['start'] + src_mapping['length'] + initial_space = src_mapping['starting_column'] + return ' ' * initial_space + content[start:end] + + def output(self, _filename): + info = '' + for contract in self.contracts: + stack_name = [] + stack_definition = [] + info += "\n\nContact Name: " + contract.name + info += " Constructor Call Sequence: " + cst = contract.constructors_declared + if cst: + stack_name.append(contract.name) + stack_definition.append(self._get_soruce_code(cst)) + for inherited_contract in contract.inheritance: + cst = inherited_contract.constructors_declared + if cst: + stack_name.append(inherited_contract.name) + stack_definition.append(self._get_soruce_code(cst)) + if len(stack_name) > 0: + info += " " + ' '.join(stack_name[len(stack_name) - 1]) + count = len(stack_name) - 2 + while count >= 0: + info += "-->" + ' '.join(stack_name[count]) + count = count - 1 + info += "\n Constructor Definitions:" + count = len(stack_definition) - 1 + while count >= 0: + info += "\n Contract name:" + str(stack_name[count]) + info += "\n" + str(stack_definition[count]) + count = count - 1 - def output(self,_filename): - for contract in self.contracts: - stack_name = [] - stack_definition = [] - print("\n\nContact Name:",contract.name) - print(" Constructor Call Sequence: ", sep=' ', end='', flush=True) - cst = contract.constructors_declared - if cst: - stack_name.append(contract.name) - stack_definition.append(self._get_soruce_code(cst)) - for inherited_contract in contract.inheritance: - cst = inherited_contract.constructors_declared - if cst: - stack_name.append(inherited_contract.name) - stack_definition.append(self._get_soruce_code(cst)) - if len(stack_name)>0: - print(" ",stack_name[len(stack_name)-1], sep=' ', end='', flush=True) - count = len(stack_name)-2 - while count>=0: - print("-->",stack_name[count], sep=' ', end='', flush=True) - count= count-1 - print("\n Constructor Definitions:") - count = len(stack_definition)-1 - while count>=0: - print("\n Contract name:", stack_name[count]) - print ("\n", stack_definition[count]) - count = count-1 + self.info(info) + res = output.Output(info) + return res diff --git a/slither/printers/summary/contract.py b/slither/printers/summary/contract.py index df7742281..e8f91d897 100644 --- a/slither/printers/summary/contract.py +++ b/slither/printers/summary/contract.py @@ -3,6 +3,7 @@ """ import collections from slither.printers.abstract_printer import AbstractPrinter +from slither.utils import output from slither.utils.colors import blue, green, magenta @@ -24,7 +25,7 @@ class ContractSummary(AbstractPrinter): all_contracts = [] for c in self.contracts: txt += blue("\n+ Contract %s\n" % c.name) - additional_fields = {"elements": []} + additional_fields = output.Output('') # Order the function with # contract_declarer -> list_functions @@ -47,15 +48,15 @@ class ContractSummary(AbstractPrinter): if function.visibility not in ['external', 'public', 'internal', 'private']: txt += " - {}  ({})\n".format(function, function.visibility) - self.add_function_to_json(function, additional_fields, additional_fields={"visibility": - function.visibility}) + additional_fields.add(function, additional_fields={"visibility": + function.visibility}) - all_contracts.append((c, additional_fields)) + all_contracts.append((c, additional_fields.data)) self.info(txt) - json = self.generate_json_result(txt) + res = self.generate_output(txt) for contract, additional_fields in all_contracts: - self.add_contract_to_json(contract, json, additional_fields=additional_fields) + res.add(contract, additional_fields=additional_fields) - return json + return res diff --git a/slither/printers/summary/data_depenency.py b/slither/printers/summary/data_depenency.py index cbd36fcdb..7e657ca0b 100644 --- a/slither/printers/summary/data_depenency.py +++ b/slither/printers/summary/data_depenency.py @@ -51,8 +51,8 @@ class DataDependency(AbstractPrinter): all_txt += txt all_tables.append((c.name, table)) - json = self.generate_json_result(all_txt) + res = self.generate_output(all_txt) for name, table in all_tables: - self.add_pretty_table_to_json(table, name, json) + res.add_pretty_table(table, name) - return json + return res diff --git a/slither/printers/summary/function.py b/slither/printers/summary/function.py index e9a71a965..f144c9736 100644 --- a/slither/printers/summary/function.py +++ b/slither/printers/summary/function.py @@ -70,8 +70,8 @@ class FunctionSummary(AbstractPrinter): all_tables.append((name, table)) all_txt += txt - json = self.generate_json_result(all_txt) + res = self.generate_output(all_txt) for name, table in all_tables: - self.add_pretty_table_to_json(table, name, json) + res.add_pretty_table(table, name) - return json + return res diff --git a/slither/printers/summary/function_ids.py b/slither/printers/summary/function_ids.py index 5aee6529c..dc1560e5d 100644 --- a/slither/printers/summary/function_ids.py +++ b/slither/printers/summary/function_ids.py @@ -37,8 +37,8 @@ class FunctionIds(AbstractPrinter): self.info(txt) - json = self.generate_json_result(txt) + res = self.generate_output(txt) for name, table in all_tables: - self.add_pretty_table_to_json(table, name, json) + res.add_pretty_table(table, name) - return json \ No newline at end of file + return res \ No newline at end of file diff --git a/slither/printers/summary/human_summary.py b/slither/printers/summary/human_summary.py index 156e353fa..9c986065d 100644 --- a/slither/printers/summary/human_summary.py +++ b/slither/printers/summary/human_summary.py @@ -4,6 +4,7 @@ Module printing summary of the contract import logging from slither.printers.abstract_printer import AbstractPrinter +from slither.utils import output from slither.utils.code_complexity import compute_cyclomatic_complexity from slither.utils.colors import green, red, yellow from slither.utils.standard_libraries import is_standard_library @@ -205,6 +206,7 @@ class PrinterHumanSummary(AbstractPrinter): 'ercs': [], } + lines_number = self._lines_number() if lines_number: total_lines, total_dep_lines = lines_number @@ -241,6 +243,7 @@ class PrinterHumanSummary(AbstractPrinter): self.info(txt) + results_contract = output.Output('') for contract in self.slither.contracts_derived: optimization, info, low, medium, high = self._get_detectors_result() contract_d = {'contract_name': contract.name, @@ -262,9 +265,11 @@ class PrinterHumanSummary(AbstractPrinter): contract_d['erc20_can_mint'] = False contract_d['erc20_race_condition_mitigated'] = race_condition_mitigated - self.add_contract_to_json(contract, results['contracts'], additional_fields=contract_d) + results_contract.add_contract(contract, additional_fields=contract_d) + + results['contracts']['elements'] = results_contract.elements - json = self.generate_json_result(txt, additional_fields=results) + json = self.generate_output(txt, additional_fields=results) return json diff --git a/slither/printers/summary/modifier_calls.py b/slither/printers/summary/modifier_calls.py index fbc62c90d..4d3cb7182 100644 --- a/slither/printers/summary/modifier_calls.py +++ b/slither/printers/summary/modifier_calls.py @@ -40,8 +40,8 @@ class Modifiers(AbstractPrinter): txt += "\n"+str(table) self.info(txt) - json = self.generate_json_result(all_txt) + res = self.generate_output(all_txt) for name, table in all_tables: - self.add_pretty_table_to_json(table, name, json) + res.add_pretty_table(table, name) - return json \ No newline at end of file + return res \ No newline at end of file diff --git a/slither/printers/summary/require_calls.py b/slither/printers/summary/require_calls.py index 51c67284d..25ae4af74 100644 --- a/slither/printers/summary/require_calls.py +++ b/slither/printers/summary/require_calls.py @@ -45,8 +45,8 @@ class RequireOrAssert(AbstractPrinter): all_tables.append((contract.name, table)) all_txt += txt - json = self.generate_json_result(all_txt) + res = self.generate_output(all_txt) for name, table in all_tables: - self.add_pretty_table_to_json(table, name, json) + res.add_pretty_table(table, name) - return json + return res diff --git a/slither/printers/summary/slithir.py b/slither/printers/summary/slithir.py index 3466d0212..f75c8b062 100644 --- a/slither/printers/summary/slithir.py +++ b/slither/printers/summary/slithir.py @@ -4,8 +4,8 @@ from slither.printers.abstract_printer import AbstractPrinter -class PrinterSlithIR(AbstractPrinter): +class PrinterSlithIR(AbstractPrinter): ARGUMENT = 'slithir' HELP = 'Print the slithIR representation of the functions' @@ -20,30 +20,32 @@ class PrinterSlithIR(AbstractPrinter): txt = "" for contract in self.contracts: - print('Contract {}'.format(contract.name)) + txt += 'Contract {}'.format(contract.name) for function in contract.functions: - print(f'\tFunction {function.canonical_name} {"" if function.is_shadowed else "(*)"}') + txt += f'\tFunction {function.canonical_name} {"" if function.is_shadowed else "(*)"}' for node in function.nodes: if node.expression: - print('\t\tExpression: {}'.format(node.expression)) - print('\t\tIRs:') + txt += '\t\tExpression: {}'.format(node.expression) + txt += '\t\tIRs:' for ir in node.irs: - print('\t\t\t{}'.format(ir)) + txt += '\t\t\t{}'.format(ir) elif node.irs: - print('\t\tIRs:') + txt += '\t\tIRs:' for ir in node.irs: - print('\t\t\t{}'.format(ir)) + txt += '\t\t\t{}'.format(ir) for modifier_statement in function.modifiers_statements: - print(f'\t\tModifier Call {modifier_statement.entry_point.expression}') + txt += f'\t\tModifier Call {modifier_statement.entry_point.expression}' for modifier_statement in function.explicit_base_constructor_calls_statements: - print(f'\t\tConstructor Call {modifier_statement.entry_point.expression}') + txt += f'\t\tConstructor Call {modifier_statement.entry_point.expression}' for modifier in contract.modifiers: - print('\tModifier {}'.format(modifier.canonical_name)) + txt += '\tModifier {}'.format(modifier.canonical_name) for node in modifier.nodes: - print(node) + txt += str(node) if node.expression: - print('\t\tExpression: {}'.format(node.expression)) - print('\t\tIRs:') + txt += '\t\tExpression: {}'.format(node.expression) + txt += '\t\tIRs:' for ir in node.irs: - print('\t\t\t{}'.format(ir)) + txt += '\t\t\t{}'.format(ir) self.info(txt) + res = self.generate_output(txt) + return res diff --git a/slither/printers/summary/slithir_ssa.py b/slither/printers/summary/slithir_ssa.py index 37acd457e..26d962401 100644 --- a/slither/printers/summary/slithir_ssa.py +++ b/slither/printers/summary/slithir_ssa.py @@ -21,24 +21,26 @@ class PrinterSlithIRSSA(AbstractPrinter): txt = "" for contract in self.contracts: - print('Contract {}'.format(contract.name)) + txt += 'Contract {}'.format(contract.name) for function in contract.functions: - print('\tFunction {}'.format(function.canonical_name)) + txt += '\tFunction {}'.format(function.canonical_name) for node in function.nodes: if node.expression: - print('\t\tExpression: {}'.format(node.expression)) + txt += '\t\tExpression: {}'.format(node.expression) if node.irs_ssa: - print('\t\tIRs:') + txt += '\t\tIRs:' for ir in node.irs_ssa: - print('\t\t\t{}'.format(ir)) + txt += '\t\t\t{}'.format(ir) for modifier in contract.modifiers: - print('\tModifier {}'.format(modifier.canonical_name)) + txt += '\tModifier {}'.format(modifier.canonical_name) for node in modifier.nodes: - print(node) + txt += str(node) if node.expression: - print('\t\tExpression: {}'.format(node.expression)) + txt += '\t\tExpression: {}'.format(node.expression) if node.irs_ssa: - print('\t\tIRs:') + txt += '\t\tIRs:' for ir in node.irs_ssa: - print('\t\t\t{}'.format(ir)) + txt += '\t\t\t{}'.format(ir) self.info(txt) + res = self.generate_output(txt) + return res diff --git a/slither/printers/summary/variable_order.py b/slither/printers/summary/variable_order.py index ffee1f940..1e78cf1df 100644 --- a/slither/printers/summary/variable_order.py +++ b/slither/printers/summary/variable_order.py @@ -36,8 +36,7 @@ class VariableOrder(AbstractPrinter): self.info(txt) - json = self.generate_json_result(txt) + res = self.generate_output(txt) for name, table in all_tables: - self.add_pretty_table_to_json(table, name, json) - - return json \ No newline at end of file + res.add_pretty_table(table, name) + return res \ No newline at end of file diff --git a/slither/slither.py b/slither/slither.py index 1dbf9e7ce..55698de74 100644 --- a/slither/slither.py +++ b/slither/slither.py @@ -165,7 +165,7 @@ class Slither(SlitherSolc): :return: List of registered printers outputs. """ - return [p.output(self.filename) for p in self._printers] + return [p.output(self.filename).data for p in self._printers] def _check_common_things(self, thing_name, cls, base_cls, instances_list): diff --git a/slither/tools/erc_conformance/__main__.py b/slither/tools/erc_conformance/__main__.py index f581db047..fe0fbb845 100644 --- a/slither/tools/erc_conformance/__main__.py +++ b/slither/tools/erc_conformance/__main__.py @@ -5,7 +5,7 @@ from collections import defaultdict from slither import Slither from crytic_compile import cryticparser from slither.utils.erc import ERCS -from slither.utils.json_utils import output_json +from slither.utils.output import output_to_json from .erc.ercs import generic_erc_checks from .erc.erc20 import check_erc20 @@ -59,7 +59,7 @@ def parse_args(): def _log_error(err, args): if args.json: - output_json(args.json, str(err), {"upgradeability-check": []}) + output_to_json(args.json, str(err), {"upgradeability-check": []}) logger.error(err) @@ -92,7 +92,7 @@ def main(): return if args.json: - output_json(args.json, None, {"upgradeability-check": ret}) + output_to_json(args.json, None, {"upgradeability-check": ret}) if __name__ == '__main__': diff --git a/slither/tools/erc_conformance/erc/erc20.py b/slither/tools/erc_conformance/erc/erc20.py index 3143ed34d..25473bc84 100644 --- a/slither/tools/erc_conformance/erc/erc20.py +++ b/slither/tools/erc_conformance/erc/erc20.py @@ -1,6 +1,6 @@ import logging -from slither.utils import json_utils +from slither.utils import output logger = logging.getLogger("Slither-conformance") @@ -18,9 +18,9 @@ def approval_race_condition(contract, ret): txt = f'\t[ ] {contract.name} is not protected for the ERC20 approval race condition' logger.info(txt) - lack_of_erc20_race_condition_protection = json_utils.generate_json_result(txt) - json_utils.add_contract_to_json(contract, lack_of_erc20_race_condition_protection) - ret["lack_of_erc20_race_condition_protection"].append(lack_of_erc20_race_condition_protection) + lack_of_erc20_race_condition_protection = output.Output(txt) + lack_of_erc20_race_condition_protection.add(contract) + ret["lack_of_erc20_race_condition_protection"].append(lack_of_erc20_race_condition_protection.data) def check_erc20(contract, ret, explored=None): diff --git a/slither/tools/erc_conformance/erc/ercs.py b/slither/tools/erc_conformance/erc/ercs.py index 523609263..5af000357 100644 --- a/slither/tools/erc_conformance/erc/ercs.py +++ b/slither/tools/erc_conformance/erc/ercs.py @@ -1,7 +1,7 @@ import logging from slither.slithir.operations import EventCall -from slither.utils import json_utils +from slither.utils import output from slither.utils.type import export_nested_types_from_variable, export_return_type_from_variable logger = logging.getLogger("Slither-conformance") @@ -25,12 +25,12 @@ def _check_signature(erc_function, contract, ret): if not state_variable_as_function or not state_variable_as_function.visibility in ['public', 'external']: txt = f'[ ] {sig} is missing {"" if required else "(optional)"}' logger.info(txt) - missing_func = json_utils.generate_json_result(txt, additional_fields={ + missing_func = output.Output(txt, additional_fields={ "function": sig, "required": required }) - json_utils.add_contract_to_json(contract, missing_func) - ret["missing_function"].append(missing_func) + missing_func.add(contract) + ret["missing_function"].append(missing_func.data) return types = [str(x) for x in export_nested_types_from_variable(state_variable_as_function)] @@ -38,12 +38,12 @@ def _check_signature(erc_function, contract, ret): if types != parameters: txt = f'[ ] {sig} is missing {"" if required else "(optional)"}' logger.info(txt) - missing_func = json_utils.generate_json_result(txt, additional_fields={ + missing_func = output.Output(txt, additional_fields={ "function": sig, "required": required }) - json_utils.add_contract_to_json(contract, missing_func) - ret["missing_function"].append(missing_func) + missing_func.add(contract) + ret["missing_function"].append(missing_func.data) return function_return_type = [export_return_type_from_variable(state_variable_as_function)] @@ -65,12 +65,12 @@ def _check_signature(erc_function, contract, ret): txt = f'\t[ ] {sig} -> () should return {return_type}' logger.info(txt) - incorrect_return = json_utils.generate_json_result(txt, additional_fields={ + incorrect_return = output.Output(txt, additional_fields={ "expected_return_type": return_type, "actual_return_type": function_return_type }) - json_utils.add_function_to_json(function, incorrect_return) - ret["incorrect_return_type"].append(incorrect_return) + incorrect_return.add(function) + ret["incorrect_return_type"].append(incorrect_return.data) elif not return_type: txt = f'\t[✓] {sig} -> () (correct return type)' @@ -79,12 +79,12 @@ def _check_signature(erc_function, contract, ret): txt = f'\t[ ] {sig} -> () should return {return_type}' logger.info(txt) - incorrect_return = json_utils.generate_json_result(txt, additional_fields={ + incorrect_return = output.Output(txt, additional_fields={ "expected_return_type": return_type, "actual_return_type": function_return_type }) - json_utils.add_function_to_json(function, incorrect_return) - ret["incorrect_return_type"].append(incorrect_return) + incorrect_return.add(function) + ret["incorrect_return_type"].append(incorrect_return.data) if view: if function_view: @@ -94,9 +94,9 @@ def _check_signature(erc_function, contract, ret): txt = f'\t[ ] {sig} should be view' logger.info(txt) - should_be_view = json_utils.generate_json_result(txt) - json_utils.add_function_to_json(function, should_be_view) - ret["should_be_view"].append(should_be_view) + should_be_view = output.Output(txt) + should_be_view.add(function) + ret["should_be_view"].append(should_be_view.data) if events: for event in events: @@ -106,11 +106,11 @@ def _check_signature(erc_function, contract, ret): txt = f'\t[ ] Must emit be view {event_sig}' logger.info(txt) - missing_event_emmited = json_utils.generate_json_result(txt, additional_fields={ + missing_event_emmited = output.Output(txt, additional_fields={ "missing_event": event_sig }) - json_utils.add_function_to_json(function, missing_event_emmited) - ret["missing_event_emmited"].append(missing_event_emmited) + missing_event_emmited.add(function) + ret["missing_event_emmited"].append(missing_event_emmited.data) else: event_found = False @@ -127,11 +127,11 @@ def _check_signature(erc_function, contract, ret): txt = f'\t[ ] Must emit be view {event_sig}' logger.info(txt) - missing_event_emmited = json_utils.generate_json_result(txt, additional_fields={ + missing_event_emmited = output.Output(txt, additional_fields={ "missing_event": event_sig }) - json_utils.add_function_to_json(function, missing_event_emmited) - ret["missing_event_emmited"].append(missing_event_emmited) + missing_event_emmited.add(function) + ret["missing_event_emmited"].append(missing_event_emmited.data) def _check_events(erc_event, contract, ret): @@ -146,12 +146,11 @@ def _check_events(erc_event, contract, ret): txt = f'[ ] {sig} is missing' logger.info(txt) - missing_event = json_utils.generate_json_result(txt, additional_fields={ + missing_event = output.Output(txt, additional_fields={ "event": sig }) - json_utils.add_contract_to_json(contract, missing_event) - ret["missing_event"].append(missing_event) - + missing_event.add(contract) + ret["missing_event"].append(missing_event.data) return txt = f'[✓] {sig} is present' @@ -166,11 +165,11 @@ def _check_events(erc_event, contract, ret): txt = f'\t[ ] parameter {i} should be indexed' logger.info(txt) - missing_event_index = json_utils.generate_json_result(txt, additional_fields={ + missing_event_index = output.Output(txt, additional_fields={ "missing_index": i }) - json_utils.add_event_to_json(event, missing_event_index) - ret["missing_event_index"].append(missing_event_index) + missing_event_index.add_event(event) + ret["missing_event_index"].append(missing_event_index.data) def generic_erc_checks(contract, erc_functions, erc_events, ret, explored=None): diff --git a/slither/tools/kspec_coverage/analysis.py b/slither/tools/kspec_coverage/analysis.py index 6ca9f9a83..d2daf03d0 100755 --- a/slither/tools/kspec_coverage/analysis.py +++ b/slither/tools/kspec_coverage/analysis.py @@ -4,17 +4,19 @@ import logging from slither.core.declarations import Function from slither.core.variables.variable import Variable from slither.utils.colors import yellow, green, red -from slither.utils import json_utils +from slither.utils import output logging.basicConfig(level=logging.WARNING) logger = logging.getLogger('Slither.kspec') + def _refactor_type(type): return { 'uint': 'uint256', 'int': 'int256' }.get(type, type) + def _get_all_covered_kspec_functions(target): # Create a set of our discovered functions which are covered covered_functions = set() @@ -56,9 +58,10 @@ def _get_slither_functions(slither): # TODO: integrate state variables all_functions_declared += list(set([s for s in slither.state_variables if s.visibility in ['public', 'external']])) slither_functions = {(function.contract.name, function.full_name): function for function in all_functions_declared} - + return slither_functions + def _generate_output(kspec, message, color, generate_json): info = "" for function in kspec: @@ -67,12 +70,13 @@ def _generate_output(kspec, message, color, generate_json): logger.info(color(info)) if generate_json: - json_kspec_present = json_utils.generate_json_result(info) + json_kspec_present = output.Output(info) for function in kspec: - json_utils.add_function_to_json(function, json_kspec_present) - return json_kspec_present + json_kspec_present.add(function) + return json_kspec_present.data return None + def _generate_output_unresolved(kspec, message, color, generate_json): info = "" for contract, function in kspec: @@ -81,8 +85,8 @@ def _generate_output_unresolved(kspec, message, color, generate_json): logger.info(color(info)) if generate_json: - json_kspec_present = json_utils.generate_json_result(info, additional_fields={"signatures": kspec}) - return json_kspec_present + json_kspec_present = output.Output(info, additional_fields={"signatures": kspec}) + return json_kspec_present.data return None @@ -95,7 +99,6 @@ def _run_coverage_analysis(args, slither, kspec_functions): kspec_functions_resolved = kspec_functions & slither_functions_set kspec_functions_unresolved = kspec_functions - kspec_functions_resolved - kspec_missing = [] kspec_present = [] @@ -114,23 +117,24 @@ def _run_coverage_analysis(args, slither, kspec_functions): red, args.json) json_kspec_missing_variables = _generate_output([f for f in kspec_missing if isinstance(f, Variable)], - "[ ] (Missing variable)", - yellow, - args.json) + "[ ] (Missing variable)", + yellow, + args.json) json_kspec_unresolved = _generate_output_unresolved(kspec_functions_unresolved, "[ ] (Unresolved)", yellow, args.json) - + # Handle unresolved kspecs if args.json: - json_utils.output_json(args.json, None, { - "functions_present": json_kspec_present, - "functions_missing": json_kspec_missing_functions, - "variables_missing": json_kspec_missing_variables, - "functions_unresolved": json_kspec_unresolved - }) - + output.output_to_json(args.json, None, { + "functions_present": json_kspec_present, + "functions_missing": json_kspec_missing_functions, + "variables_missing": json_kspec_missing_variables, + "functions_unresolved": json_kspec_unresolved + }) + + def run_analysis(args, slither, kspec): # Get all of our kspec'd functions (tuple(contract_name, function_name)). if ',' in kspec: @@ -143,4 +147,3 @@ def run_analysis(args, slither, kspec): # Run coverage analysis _run_coverage_analysis(args, slither, kspec_functions) - diff --git a/slither/tools/upgradeability/__main__.py b/slither/tools/upgradeability/__main__.py index 305a43dae..df43a7dfb 100644 --- a/slither/tools/upgradeability/__main__.py +++ b/slither/tools/upgradeability/__main__.py @@ -7,7 +7,7 @@ from slither import Slither from crytic_compile import cryticparser from slither.exceptions import SlitherException from slither.utils.colors import red -from slither.utils.json_utils import output_json +from slither.utils.output import output_to_json from .compare_variables_order import compare_variables_order from .compare_function_ids import compare_function_ids @@ -135,7 +135,7 @@ def main(): info = 'Contract {} not found in {}'.format(v1_name, v1.filename) logger.error(red(info)) if args.json: - output_json(args.json, str(info), {"upgradeability-check": json_results}) + output_to_json(args.json, str(info), {"upgradeability-check": json_results}) return _checks_on_contract(v1_contract, json_results) @@ -153,7 +153,7 @@ def main(): info = 'Proxy {} not found in {}'.format(args.proxy_name, proxy.filename) logger.error(red(info)) if args.json: - output_json(args.json, str(info), {"upgradeability-check": json_results}) + output_to_json(args.json, str(info), {"upgradeability-check": json_results}) return json_results['proxy-present'] = True _checks_on_contract_and_proxy(v1_contract, proxy_contract, json_results) @@ -170,7 +170,7 @@ def main(): info = 'New logic contract {} not found in {}'.format(args.new_contract_name, v2.filename) logger.error(red(info)) if args.json: - output_json(args.json, str(info), {"upgradeability-check": json_results}) + output_to_json(args.json, str(info), {"upgradeability-check": json_results}) return json_results['contract_v2-present'] = True @@ -183,12 +183,12 @@ def main(): _checks_on_contract_update(v1_contract, v2_contract, json_results) if args.json: - output_json(args.json, None, {"upgradeability-check": json_results}) + output_to_json(args.json, None, {"upgradeability-check": json_results}) except SlitherException as e: logger.error(str(e)) if args.json: - output_json(args.json, str(e), {"upgradeability-check": json_results}) + output_to_json(args.json, str(e), {"upgradeability-check": json_results}) return # endregion diff --git a/slither/tools/upgradeability/check_initialization.py b/slither/tools/upgradeability/check_initialization.py index 446468389..4fe07801a 100644 --- a/slither/tools/upgradeability/check_initialization.py +++ b/slither/tools/upgradeability/check_initialization.py @@ -1,7 +1,7 @@ import logging from slither.slithir.operations import InternalCall -from slither.utils import json_utils +from slither.utils.output import Output from slither.utils.colors import red, yellow, green logger = logging.getLogger("Slither-check-upgradeability") @@ -74,9 +74,9 @@ def check_initialization(contract): initializer_modifier_missing = True info = f'{f.canonical_name} does not call the initializer modifier' logger.info(red(info)) - json_elem = json_utils.generate_json_result(info) - json_utils.add_function_to_json(f, json_elem) - results['missing-initializer-modifier'].append(json_elem) + res = Output(info) + res.add(f) + results['missing-initializer-modifier'].append(res.data) if not initializer_modifier_missing: logger.info(green('All the init functions have the initializer modifier')) @@ -103,10 +103,10 @@ def check_initialization(contract): for f in missing_calls: info = f'Missing call to {f.canonical_name} in {most_derived_init.canonical_name}' logger.info(red(info)) - json_elem = json_utils.generate_json_result(info) - json_utils.add_function_to_json(f, json_elem, {"is_most_derived_init_function": False}) - json_utils.add_function_to_json(most_derived_init, json_elem, {"is_most_derived_init_function": True}) - results['missing-calls'].append(json_elem) + res = Output(info) + res.add(f, {"is_most_derived_init_function": False}) + res.add(most_derived_init, {"is_most_derived_init_function": True}) + results['missing-calls'].append(res.data) missing_call = True if not missing_call: logger.info(green('No missing call to an init function found')) @@ -117,9 +117,9 @@ def check_initialization(contract): for f in double_calls: info = f'{f.canonical_name} is called multiple times in {most_derived_init.full_name}' logger.info(red(info)) - json_elem = json_utils.generate_json_result(info) - json_utils.add_function_to_json(f, json_elem) - results['multiple-calls'].append(json_elem) + res = Output(info) + res.add(f) + results['multiple-calls'].append(res.data) double_calls_found = True if not double_calls_found: logger.info(green('No double call to init functions found')) @@ -128,9 +128,9 @@ def check_initialization(contract): init_info = f'{contract.name} needs to be initialized by {most_derived_init.full_name}\n' logger.info(green('Check the deployement script to ensure that these functions are called:\n' + init_info)) - json_elem = json_utils.generate_json_result(init_info) - json_utils.add_function_to_json(most_derived_init, json_elem) - results['initialize_target'] = json_elem + res = Output(init_info) + res.add(most_derived_init) + results['initialize_target'] = res.data if not error_found: logger.info(green('No error found')) diff --git a/slither/tools/upgradeability/check_variable_initialization.py b/slither/tools/upgradeability/check_variable_initialization.py index cedfbc314..cb2473f67 100644 --- a/slither/tools/upgradeability/check_variable_initialization.py +++ b/slither/tools/upgradeability/check_variable_initialization.py @@ -1,6 +1,6 @@ import logging -from slither.utils import json_utils +from slither.utils import output from slither.utils.colors import red, green logger = logging.getLogger("Slither-check-upgradeability") @@ -20,9 +20,9 @@ def check_variable_initialization(contract): if s.initialized and not s.is_constant: info = f'{s.canonical_name} has an initial value ({s.source_mapping_str})' logger.info(red(info)) - json_elem = json_utils.generate_json_result(info) - json_utils.add_variable_to_json(s, json_elem) - results['variables-initialized'].append(json_elem) + res = output.Output(info) + res.add(s) + results['variables-initialized'].append(res.data) error_found = True if not error_found: diff --git a/slither/tools/upgradeability/compare_function_ids.py b/slither/tools/upgradeability/compare_function_ids.py index da7eda61e..34b63d8bf 100644 --- a/slither/tools/upgradeability/compare_function_ids.py +++ b/slither/tools/upgradeability/compare_function_ids.py @@ -4,10 +4,9 @@ ''' import logging -from slither import Slither from slither.core.declarations import Function from slither.exceptions import SlitherError -from slither.utils import json_utils +from slither.utils.output import Output from slither.utils.function import get_function_id from slither.utils.colors import red, green @@ -63,16 +62,10 @@ def compare_function_ids(implem, proxy): info = f'Function id collision found: {implem_function.canonical_name} ({implem_function.source_mapping_str}) {proxy_function.canonical_name} ({proxy_function.source_mapping_str})' logger.info(red(info)) - json_elem = json_utils.generate_json_result(info) - if isinstance(implem_function, Function): - json_utils.add_function_to_json(implem_function, json_elem) - else: - json_utils.add_variable_to_json(implem_function, json_elem) - if isinstance(proxy_function, Function): - json_utils.add_function_to_json(proxy_function, json_elem) - else: - json_utils.add_variable_to_json(proxy_function, json_elem) - results['function-id-collision'].append(json_elem) + res = Output(info) + res.add(implem_function) + res.add(proxy_function) + results['function-id-collision'].append(res.data) else: @@ -82,17 +75,10 @@ def compare_function_ids(implem, proxy): info = f'Shadowing between {implem_function.canonical_name} ({implem_function.source_mapping_str}) and {proxy_function.canonical_name} ({proxy_function.source_mapping_str})' logger.info(red(info)) - json_elem = json_utils.generate_json_result(info) - json_elem = json_utils.generate_json_result(info) - if isinstance(implem_function, Function): - json_utils.add_function_to_json(implem_function, json_elem) - else: - json_utils.add_variable_to_json(implem_function, json_elem) - if isinstance(proxy_function, Function): - json_utils.add_function_to_json(proxy_function, json_elem) - else: - json_utils.add_variable_to_json(proxy_function, json_elem) - results['shadowing'].append(json_elem) + res = Output(info) + res.add(implem_function) + res.add(proxy_function) + results['shadowing'].append(res.data) if not error_found: logger.info(green('No error found')) diff --git a/slither/tools/upgradeability/compare_variables_order.py b/slither/tools/upgradeability/compare_variables_order.py index 3b8fd9c30..ea5852d3f 100644 --- a/slither/tools/upgradeability/compare_variables_order.py +++ b/slither/tools/upgradeability/compare_variables_order.py @@ -3,7 +3,7 @@ ''' import logging -from slither.utils import json_utils +from slither.utils.output import Output from slither.utils.colors import red, green, yellow logger = logging.getLogger("Slither-check-upgradeability") @@ -32,9 +32,9 @@ def compare_variables_order(contract1, contract2, missing_variable_check=True): info = f'Variable only in {contract1.name}: {variable1.name} ({variable1.source_mapping_str})' logger.info(yellow(info)) - json_elem = json_utils.generate_json_result(info) - json_utils.add_variable_to_json(variable1, json_elem) - results['missing_variables'].append(json_elem) + res = Output(info) + res.add(variable1) + results['missing_variables'].append(res.data) error_found = True continue @@ -47,10 +47,10 @@ def compare_variables_order(contract1, contract2, missing_variable_check=True): info += f'\t Variable {idx} in {contract2.name}: {variable2.name} {variable2.type} ({variable2.source_mapping_str})\n' logger.info(red(info)) - json_elem = json_utils.generate_json_result(info, additional_fields={'index': idx}) - json_utils.add_variable_to_json(variable1, json_elem) - json_utils.add_variable_to_json(variable2, json_elem) - results['different-variables'].append(json_elem) + res = Output(info, additional_fields={'index': idx}) + res.add(variable1) + res.add(variable2) + results['different-variables'].append(res.data) error_found = True @@ -61,9 +61,9 @@ def compare_variables_order(contract1, contract2, missing_variable_check=True): info = f'Extra variables in {contract2.name}: {variable2.name} ({variable2.source_mapping_str})\n' logger.info(yellow(info)) - json_elem = json_utils.generate_json_result(info, additional_fields={'index': idx}) - json_utils.add_variable_to_json(variable2, json_elem) - results['extra-variables'].append(json_elem) + res = Output(info, additional_fields={'index': idx}) + res.add(variable2) + results['extra-variables'].append(res.data) idx = idx + 1 if not error_found: diff --git a/slither/tools/upgradeability/constant_checks.py b/slither/tools/upgradeability/constant_checks.py index d66b41fc2..e25924350 100644 --- a/slither/tools/upgradeability/constant_checks.py +++ b/slither/tools/upgradeability/constant_checks.py @@ -1,6 +1,6 @@ import logging -from slither.utils import json_utils +from slither.utils.output import Output from slither.utils.colors import red, yellow, green logger = logging.getLogger("Slither-check-upgradeability") @@ -49,30 +49,30 @@ def constant_conformance_check(contract_v1, contract_v2): info = f'{state_v1.canonical_name} ({state_v1.source_mapping_str}) was constant and {state_v2.canonical_name} is not ({state_v2.source_mapping_str})' logger.info(red(info)) - json_elem = json_utils.generate_json_result(info) - json_utils.add_variable_to_json(state_v1, json_elem) - json_utils.add_variable_to_json(state_v2, json_elem) - results['were_constants'].append(json_elem) + res = Output(info) + res.add(state_v1) + res.add(state_v2) + results['were_constants'].append(res.data) error_found = True elif state_v2.is_constant: info = f'{state_v1.canonical_name} ({state_v1.source_mapping_str}) was not constant but {state_v2.canonical_name} is ({state_v2.source_mapping_str})' logger.info(red(info)) - json_elem = json_utils.generate_json_result(info) - json_utils.add_variable_to_json(state_v1, json_elem) - json_utils.add_variable_to_json(state_v2, json_elem) - results['became_constants'].append(json_elem) + res = Output(info) + res.add(state_v1) + res.add(state_v2) + results['became_constants'].append(res.data) error_found = True else: info = f'{state_v1.canonical_name} not found in {contract_v2.name}, not check was done' logger.info(yellow(info)) - json_elem = json_utils.generate_json_result(info) - json_utils.add_variable_to_json(state_v1, json_elem) - json_utils.add_contract_to_json(contract_v2, json_elem) - results['not_found_in_v2'].append(json_elem) + res = Output(info) + res.add(state_v1) + res.add(contract_v2) + results['not_found_in_v2'].append(res.data) error_found = True diff --git a/slither/utils/json_utils.py b/slither/utils/json_utils.py deleted file mode 100644 index 3ae2b8862..000000000 --- a/slither/utils/json_utils.py +++ /dev/null @@ -1,452 +0,0 @@ -import os -import json -import logging -from collections import OrderedDict - -from slither.core.cfg.node import Node -from slither.core.declarations import Contract, Function, Enum, Event, Structure, Pragma -from slither.core.source_mapping.source_mapping import SourceMapping -from slither.core.variables.variable import Variable -from slither.exceptions import SlitherError -from slither.utils.colors import yellow - -logger = logging.getLogger("Slither") - - -################################################################################### -################################################################################### -# region Output -################################################################################### -################################################################################### - -def output_json(filename, error, results): - """ - - :param filename: Filename where the json will be written. If None or "-", write to stdout - :param error: Error to report - :param results: Results to report - :param logger: Logger where to log potential info - :return: - """ - # Create our encapsulated JSON result. - json_result = { - "success": error is None, - "error": error, - "results": results - } - - if filename == "-": - filename = None - - # Determine if we should output to stdout - if filename is None: - # Write json to console - print(json.dumps(json_result)) - else: - # Write json to file - if os.path.isfile(filename): - logger.info(yellow(f'{filename} exists already, the overwrite is prevented')) - else: - with open(filename, 'w', encoding='utf8') as f: - json.dump(json_result, f, indent=2) - - -# endregion -################################################################################### -################################################################################### -# region Json generation -################################################################################### -################################################################################### - -def _convert_to_description(d): - if isinstance(d, str): - return d - - if not isinstance(d, SourceMapping): - raise SlitherError(f'{d} does not inherit from SourceMapping, conversion impossible') - - if isinstance(d, Node): - if d.expression: - return f'{d.expression} ({d.source_mapping_str})' - else: - return f'{str(d)} ({d.source_mapping_str})' - - if hasattr(d, 'canonical_name'): - return f'{d.canonical_name} ({d.source_mapping_str})' - - if hasattr(d, 'name'): - return f'{d.name} ({d.source_mapping_str})' - - raise SlitherError(f'{type(d)} cannot be converted (no name, or canonical_name') - -def _convert_to_markdown(d, markdown_root): - if isinstance(d, str): - return d - - if not isinstance(d, SourceMapping): - raise SlitherError(f'{d} does not inherit from SourceMapping, conversion impossible') - - if isinstance(d, Node): - if d.expression: - return f'[{d.expression}]({d.source_mapping_to_markdown(markdown_root)})' - else: - return f'[{str(d)}]({d.source_mapping_to_markdown(markdown_root)})' - - if hasattr(d, 'canonical_name'): - return f'[{d.canonical_name}]({d.source_mapping_to_markdown(markdown_root)})' - - if hasattr(d, 'name'): - return f'[{d.name}]({d.source_mapping_to_markdown(markdown_root)})' - - raise SlitherError(f'{type(d)} cannot be converted (no name, or canonical_name') - -def generate_json_result(info, additional_fields=None, markdown_root='', standard_format=False): - if additional_fields is None: - additional_fields = {} - d = OrderedDict() - d['elements'] = [] - d['description'] = ''.join(_convert_to_description(d) for d in info) - d['markdown'] = ''.join(_convert_to_markdown(d, markdown_root) for d in info) - - if standard_format: - to_add = [i for i in info if not isinstance(i, str)] - - for add in to_add: - if isinstance(add, Variable): - add_variable_to_json(add, d) - elif isinstance(add, Contract): - add_contract_to_json(add, d) - elif isinstance(add, Function): - add_function_to_json(add, d) - elif isinstance(add, Enum): - add_enum_to_json(add, d) - elif isinstance(add, Event): - add_event_to_json(add, d) - elif isinstance(add, Structure): - add_struct_to_json(add, d) - elif isinstance(add, Pragma): - add_pragma_to_json(add, d) - elif isinstance(add, Node): - add_node_to_json(add, d) - else: - raise SlitherError(f'Impossible to add {type(add)} to the json') - - if additional_fields: - d['additional_fields'] = additional_fields - - return d - - -# endregion -################################################################################### -################################################################################### -# region Internal functions -################################################################################### -################################################################################### - -def _create_base_element(type, name, source_mapping, type_specific_fields=None, additional_fields=None): - if additional_fields is None: - additional_fields = {} - if type_specific_fields is None: - type_specific_fields = {} - element = {'type': type, - 'name': name, - 'source_mapping': source_mapping} - if type_specific_fields: - element['type_specific_fields'] = type_specific_fields - if additional_fields: - element['additional_fields'] = additional_fields - return element - - -def _create_parent_element(element): - from slither.core.children.child_contract import ChildContract - from slither.core.children.child_function import ChildFunction - from slither.core.children.child_inheritance import ChildInheritance - if isinstance(element, ChildInheritance): - if element.contract_declarer: - contract = {'elements': []} - add_contract_to_json(element.contract_declarer, contract) - return contract['elements'][0] - elif isinstance(element, ChildContract): - if element.contract: - contract = {'elements': []} - add_contract_to_json(element.contract, contract) - return contract['elements'][0] - elif isinstance(element, ChildFunction): - if element.function: - function = {'elements': []} - add_function_to_json(element.function, function) - return function['elements'][0] - return None - - -# endregion -################################################################################### -################################################################################### -# region Variables -################################################################################### -################################################################################### - -def add_variable_to_json(variable, d, additional_fields=None): - if additional_fields is None: - additional_fields = {} - type_specific_fields = { - 'parent': _create_parent_element(variable) - } - element = _create_base_element('variable', - variable.name, - variable.source_mapping, - type_specific_fields, - additional_fields) - d['elements'].append(element) - - -def add_variables_to_json(variables, d): - for variable in sorted(variables, key=lambda x: x.name): - add_variable_to_json(variable, d) - - -# endregion -################################################################################### -################################################################################### -# region Contract -################################################################################### -################################################################################### - -def add_contract_to_json(contract, d, additional_fields=None): - if additional_fields is None: - additional_fields = {} - element = _create_base_element('contract', - contract.name, - contract.source_mapping, - {}, - additional_fields) - d['elements'].append(element) - - -# endregion -################################################################################### -################################################################################### -# region Functions -################################################################################### -################################################################################### - -def add_function_to_json(function, d, additional_fields=None): - if additional_fields is None: - additional_fields = {} - type_specific_fields = { - 'parent': _create_parent_element(function), - 'signature': function.full_name - } - element = _create_base_element('function', - function.name, - function.source_mapping, - type_specific_fields, - additional_fields) - d['elements'].append(element) - - -def add_functions_to_json(functions, d, additional_fields=None): - if additional_fields is None: - additional_fields = {} - for function in sorted(functions, key=lambda x: x.name): - add_function_to_json(function, d, additional_fields) - - -# endregion -################################################################################### -################################################################################### -# region Enum -################################################################################### -################################################################################### - - -def add_enum_to_json(enum, d, additional_fields=None): - if additional_fields is None: - additional_fields = {} - type_specific_fields = { - 'parent': _create_parent_element(enum) - } - element = _create_base_element('enum', - enum.name, - enum.source_mapping, - type_specific_fields, - additional_fields) - d['elements'].append(element) - - -# endregion -################################################################################### -################################################################################### -# region Structures -################################################################################### -################################################################################### - -def add_struct_to_json(struct, d, additional_fields=None): - if additional_fields is None: - additional_fields = {} - type_specific_fields = { - 'parent': _create_parent_element(struct) - } - element = _create_base_element('struct', - struct.name, - struct.source_mapping, - type_specific_fields, - additional_fields) - d['elements'].append(element) - - -# endregion -################################################################################### -################################################################################### -# region Events -################################################################################### -################################################################################### - -def add_event_to_json(event, d, additional_fields=None): - if additional_fields is None: - additional_fields = {} - type_specific_fields = { - 'parent': _create_parent_element(event), - 'signature': event.full_name - } - element = _create_base_element('event', - event.name, - event.source_mapping, - type_specific_fields, - additional_fields) - - d['elements'].append(element) - - -# endregion -################################################################################### -################################################################################### -# region Nodes -################################################################################### -################################################################################### - -def add_node_to_json(node, d, additional_fields=None): - if additional_fields is None: - additional_fields = {} - type_specific_fields = { - 'parent': _create_parent_element(node), - } - node_name = str(node.expression) if node.expression else "" - element = _create_base_element('node', - node_name, - node.source_mapping, - type_specific_fields, - additional_fields) - d['elements'].append(element) - - -def add_nodes_to_json(nodes, d): - for node in sorted(nodes, key=lambda x: x.node_id): - add_node_to_json(node, d) - - -# endregion -################################################################################### -################################################################################### -# region Pragma -################################################################################### -################################################################################### - -def add_pragma_to_json(pragma, d, additional_fields=None): - if additional_fields is None: - additional_fields = {} - type_specific_fields = { - 'directive': pragma.directive - } - element = _create_base_element('pragma', - pragma.version, - pragma.source_mapping, - type_specific_fields, - additional_fields) - d['elements'].append(element) - - -# endregion -################################################################################### -################################################################################### -# region File -################################################################################### -################################################################################### - - -def add_file_to_json(filename, content, d, additional_fields=None): - if additional_fields is None: - additional_fields = {} - type_specific_fields = { - 'filename': filename, - 'content': content - } - element = _create_base_element('file', - type_specific_fields, - additional_fields) - - d['elements'].append(element) - - -# endregion -################################################################################### -################################################################################### -# region Pretty Table -################################################################################### -################################################################################### - - -def add_pretty_table_to_json(content, name, d, additional_fields=None): - if additional_fields is None: - additional_fields = {} - type_specific_fields = { - 'content': content, - 'name': name - } - element = _create_base_element('pretty_table', - type_specific_fields, - additional_fields) - - d['elements'].append(element) - - -# endregion -################################################################################### -################################################################################### -# region Others -################################################################################### -################################################################################### - -def add_other_to_json(name, source_mapping, d, slither, additional_fields=None): - # If this a tuple with (filename, start, end), convert it to a source mapping. - if additional_fields is None: - additional_fields = {} - if isinstance(source_mapping, tuple): - # Parse the source id - (filename, start, end) = source_mapping - source_id = next( - (source_unit_id for (source_unit_id, source_unit_filename) in slither.source_units.items() if - source_unit_filename == filename), -1) - - # Convert to a source mapping string - source_mapping = f"{start}:{end}:{source_id}" - - # If this is a source mapping string, parse it. - if isinstance(source_mapping, str): - source_mapping_str = source_mapping - source_mapping = SourceMapping() - source_mapping.set_offset(source_mapping_str, slither) - - # If this is a source mapping object, get the underlying source mapping dictionary - if isinstance(source_mapping, SourceMapping): - source_mapping = source_mapping.source_mapping - - # Create the underlying element and add it to our resulting json - element = _create_base_element('other', - name, - source_mapping, - {}, - additional_fields) - d['elements'].append(element) diff --git a/slither/utils/output.py b/slither/utils/output.py new file mode 100644 index 000000000..cbceef467 --- /dev/null +++ b/slither/utils/output.py @@ -0,0 +1,454 @@ +import os +import json +import logging +from collections import OrderedDict + +from slither.core.cfg.node import Node +from slither.core.declarations import Contract, Function, Enum, Event, Structure, Pragma +from slither.core.source_mapping.source_mapping import SourceMapping +from slither.core.variables.variable import Variable +from slither.exceptions import SlitherError +from slither.utils.colors import yellow + +logger = logging.getLogger("Slither") + + +################################################################################### +################################################################################### +# region Output +################################################################################### +################################################################################### + +def output_to_json(filename, error, results): + """ + + :param filename: Filename where the json will be written. If None or "-", write to stdout + :param error: Error to report + :param results: Results to report + :param logger: Logger where to log potential info + :return: + """ + # Create our encapsulated JSON result. + json_result = { + "success": error is None, + "error": error, + "results": results + } + + if filename == "-": + filename = None + + # Determine if we should output to stdout + if filename is None: + # Write json to console + print(json.dumps(json_result)) + else: + # Write json to file + if os.path.isfile(filename): + logger.info(yellow(f'{filename} exists already, the overwrite is prevented')) + else: + with open(filename, 'w', encoding='utf8') as f: + json.dump(json_result, f, indent=2) + + +# endregion +################################################################################### +################################################################################### +# region Json generation +################################################################################### +################################################################################### + +def _convert_to_description(d): + if isinstance(d, str): + return d + + if not isinstance(d, SourceMapping): + raise SlitherError(f'{d} does not inherit from SourceMapping, conversion impossible') + + if isinstance(d, Node): + if d.expression: + return f'{d.expression} ({d.source_mapping_str})' + else: + return f'{str(d)} ({d.source_mapping_str})' + + if hasattr(d, 'canonical_name'): + return f'{d.canonical_name} ({d.source_mapping_str})' + + if hasattr(d, 'name'): + return f'{d.name} ({d.source_mapping_str})' + + raise SlitherError(f'{type(d)} cannot be converted (no name, or canonical_name') + + +def _convert_to_markdown(d, markdown_root): + if isinstance(d, str): + return d + + if not isinstance(d, SourceMapping): + raise SlitherError(f'{d} does not inherit from SourceMapping, conversion impossible') + + if isinstance(d, Node): + if d.expression: + return f'[{d.expression}]({d.source_mapping_to_markdown(markdown_root)})' + else: + return f'[{str(d)}]({d.source_mapping_to_markdown(markdown_root)})' + + if hasattr(d, 'canonical_name'): + return f'[{d.canonical_name}]({d.source_mapping_to_markdown(markdown_root)})' + + if hasattr(d, 'name'): + return f'[{d.name}]({d.source_mapping_to_markdown(markdown_root)})' + + raise SlitherError(f'{type(d)} cannot be converted (no name, or canonical_name') + + +# endregion +################################################################################### +################################################################################### +# region Internal functions +################################################################################### +################################################################################### + +def _create_base_element(type, name, source_mapping, type_specific_fields=None, additional_fields=None): + if additional_fields is None: + additional_fields = {} + if type_specific_fields is None: + type_specific_fields = {} + element = {'type': type, + 'name': name, + 'source_mapping': source_mapping} + if type_specific_fields: + element['type_specific_fields'] = type_specific_fields + if additional_fields: + element['additional_fields'] = additional_fields + return element + + +def _create_parent_element(element): + from slither.core.children.child_contract import ChildContract + from slither.core.children.child_function import ChildFunction + from slither.core.children.child_inheritance import ChildInheritance + if isinstance(element, ChildInheritance): + if element.contract_declarer: + contract = Output('') + contract.add_contract(element.contract_declarer) + return contract.data['elements'][0] + elif isinstance(element, ChildContract): + if element.contract: + contract = Output('') + contract.add_contract(element.contract) + return contract.data['elements'][0] + elif isinstance(element, ChildFunction): + if element.function: + function = Output('') + function.add_function(element.function) + return function.data['elements'][0] + return None + + +class Output: + + def __init__(self, info, additional_fields=None, markdown_root='', standard_format=True): + if additional_fields is None: + additional_fields = {} + + # Allow info to be a string to simplify the API + if isinstance(info, str): + info = [info] + + self._data = OrderedDict() + self._data['elements'] = [] + self._data['description'] = ''.join(_convert_to_description(d) for d in info) + self._data['markdown'] = ''.join(_convert_to_markdown(d, markdown_root) for d in info) + + if standard_format: + to_add = [i for i in info if not isinstance(i, str)] + + for add in to_add: + self.add(add) + + if additional_fields: + self._data['additional_fields'] = additional_fields + + + def add(self, add, additional_fields=None): + if isinstance(add, Variable): + self.add_variable(add, additional_fields=additional_fields) + elif isinstance(add, Contract): + self.add_contract(add, additional_fields=additional_fields) + elif isinstance(add, Function): + self.add_function(add, additional_fields=additional_fields) + elif isinstance(add, Enum): + self.add_enum(add, additional_fields=additional_fields) + elif isinstance(add, Event): + self.add_event(add, additional_fields=additional_fields) + elif isinstance(add, Structure): + self.add_struct(add, additional_fields=additional_fields) + elif isinstance(add, Pragma): + self.add_pragma(add, additional_fields=additional_fields) + elif isinstance(add, Node): + self.add_node(add, additional_fields=additional_fields) + else: + raise SlitherError(f'Impossible to add {type(add)} to the json') + + @property + def data(self): + return self._data + + @property + def elements(self): + return self._data['elements'] + + # endregion + ################################################################################### + ################################################################################### + # region Variables + ################################################################################### + ################################################################################### + + def add_variable(self, variable, additional_fields=None): + if additional_fields is None: + additional_fields = {} + type_specific_fields = { + 'parent': _create_parent_element(variable) + } + element = _create_base_element('variable', + variable.name, + variable.source_mapping, + type_specific_fields, + additional_fields) + self._data['elements'].append(element) + + def add_variables_to_output(self, variables): + for variable in sorted(variables, key=lambda x: x.name): + self.add_variable(variable) + + # endregion + ################################################################################### + ################################################################################### + # region Contract + ################################################################################### + ################################################################################### + + def add_contract(self, contract, additional_fields=None): + if additional_fields is None: + additional_fields = {} + element = _create_base_element('contract', + contract.name, + contract.source_mapping, + {}, + additional_fields) + self._data['elements'].append(element) + + # endregion + ################################################################################### + ################################################################################### + # region Functions + ################################################################################### + ################################################################################### + + def add_function(self, function, additional_fields=None): + if additional_fields is None: + additional_fields = {} + type_specific_fields = { + 'parent': _create_parent_element(function), + 'signature': function.full_name + } + element = _create_base_element('function', + function.name, + function.source_mapping, + type_specific_fields, + additional_fields) + self._data['elements'].append(element) + + def add_functions(self, functions, additional_fields=None): + if additional_fields is None: + additional_fields = {} + for function in sorted(functions, key=lambda x: x.name): + self.add_function(function, additional_fields) + + # endregion + ################################################################################### + ################################################################################### + # region Enum + ################################################################################### + ################################################################################### + + def add_enum(self, enum, additional_fields=None): + if additional_fields is None: + additional_fields = {} + type_specific_fields = { + 'parent': _create_parent_element(enum) + } + element = _create_base_element('enum', + enum.name, + enum.source_mapping, + type_specific_fields, + additional_fields) + self._data['elements'].append(element) + + # endregion + ################################################################################### + ################################################################################### + # region Structures + ################################################################################### + ################################################################################### + + def add_struct(self, struct, additional_fields=None): + if additional_fields is None: + additional_fields = {} + type_specific_fields = { + 'parent': _create_parent_element(struct) + } + element = _create_base_element('struct', + struct.name, + struct.source_mapping, + type_specific_fields, + additional_fields) + self._data['elements'].append(element) + + # endregion + ################################################################################### + ################################################################################### + # region Events + ################################################################################### + ################################################################################### + + def add_event(self, event, additional_fields=None): + if additional_fields is None: + additional_fields = {} + type_specific_fields = { + 'parent': _create_parent_element(event), + 'signature': event.full_name + } + element = _create_base_element('event', + event.name, + event.source_mapping, + type_specific_fields, + additional_fields) + + self._data['elements'].append(element) + + # endregion + ################################################################################### + ################################################################################### + # region Nodes + ################################################################################### + ################################################################################### + + def add_node(self, node, additional_fields=None): + if additional_fields is None: + additional_fields = {} + type_specific_fields = { + 'parent': _create_parent_element(node), + } + node_name = str(node.expression) if node.expression else "" + element = _create_base_element('node', + node_name, + node.source_mapping, + type_specific_fields, + additional_fields) + self._data['elements'].append(element) + + def add_nodes(self, nodes): + for node in sorted(nodes, key=lambda x: x.node_id): + self.add_node(node) + + # endregion + ################################################################################### + ################################################################################### + # region Pragma + ################################################################################### + ################################################################################### + + def add_pragma(self, pragma, additional_fields=None): + if additional_fields is None: + additional_fields = {} + type_specific_fields = { + 'directive': pragma.directive + } + element = _create_base_element('pragma', + pragma.version, + pragma.source_mapping, + type_specific_fields, + additional_fields) + self._data['elements'].append(element) + + # endregion + ################################################################################### + ################################################################################### + # region File + ################################################################################### + ################################################################################### + + def add_file(self, filename, content, additional_fields=None): + if additional_fields is None: + additional_fields = {} + type_specific_fields = { + 'filename': filename, + 'content': content + } + element = _create_base_element('file', + type_specific_fields, + additional_fields) + + self._data['elements'].append(element) + + # endregion + ################################################################################### + ################################################################################### + # region Pretty Table + ################################################################################### + ################################################################################### + + def add_pretty_table(self, content, name, additional_fields=None): + if additional_fields is None: + additional_fields = {} + type_specific_fields = { + 'content': content, + 'name': name + } + element = _create_base_element('pretty_table', + type_specific_fields, + additional_fields) + + self._data['elements'].append(element) + + # endregion + ################################################################################### + ################################################################################### + # region Others + ################################################################################### + ################################################################################### + + def add_other(self, name, source_mapping, slither, additional_fields=None): + # If this a tuple with (filename, start, end), convert it to a source mapping. + if additional_fields is None: + additional_fields = {} + if isinstance(source_mapping, tuple): + # Parse the source id + (filename, start, end) = source_mapping + source_id = next( + (source_unit_id for (source_unit_id, source_unit_filename) in slither.source_units.items() if + source_unit_filename == filename), -1) + + # Convert to a source mapping string + source_mapping = f"{start}:{end}:{source_id}" + + # If this is a source mapping string, parse it. + if isinstance(source_mapping, str): + source_mapping_str = source_mapping + source_mapping = SourceMapping() + source_mapping.set_offset(source_mapping_str, slither) + + # If this is a source mapping object, get the underlying source mapping dictionary + if isinstance(source_mapping, SourceMapping): + source_mapping = source_mapping.source_mapping + + # Create the underlying element and add it to our resulting json + element = _create_base_element('other', + name, + source_mapping, + {}, + additional_fields) + self._data['elements'].append(element) From f10b4afc959c1bf7018c508750a6f02b473746c3 Mon Sep 17 00:00:00 2001 From: Josselin Date: Tue, 12 Nov 2019 11:17:17 +0100 Subject: [PATCH 220/223] Minor --- slither/utils/output.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/slither/utils/output.py b/slither/utils/output.py index cbceef467..b9bacd274 100644 --- a/slither/utils/output.py +++ b/slither/utils/output.py @@ -219,7 +219,7 @@ class Output: additional_fields) self._data['elements'].append(element) - def add_variables_to_output(self, variables): + def add_variables(self, variables): for variable in sorted(variables, key=lambda x: x.name): self.add_variable(variable) From be3bd84630688bcf5198391992d3a7da0e0cdea2 Mon Sep 17 00:00:00 2001 From: Josselin Date: Tue, 12 Nov 2019 14:06:35 +0100 Subject: [PATCH 221/223] Add id to Output --- slither/utils/output.py | 29 +++++++++++++++++++ .../arbitrary_send-0.5.1.arbitrary-send.json | 2 ++ .../arbitrary_send.arbitrary-send.json | 2 ++ tests/expected_json/backdoor.backdoor.json | 1 + tests/expected_json/backdoor.suicidal.json | 1 + ...onst_state_variables.constable-states.json | 6 ++++ .../constant-0.5.1.constant-function.json | 1 + .../constant.constant-function.json | 3 ++ ..._delegatecall.controlled-delegatecall.json | 2 ++ ...deprecated_calls.deprecated-standards.json | 8 +++++ .../erc20_indexed.erc20-indexed.json | 4 +++ .../external_function.external-function.json | 5 ++++ ...incorrect_equality.incorrect-equality.json | 12 ++++++++ ...rrect_erc20_interface.erc20-interface.json | 6 ++++ ...ect_erc721_interface.erc721-interface.json | 10 +++++++ ...line_assembly_contract-0.5.1.assembly.json | 1 + .../inline_assembly_contract.assembly.json | 1 + ...nline_assembly_library-0.5.1.assembly.json | 2 ++ .../inline_assembly_library.assembly.json | 2 ++ .../locked_ether-0.5.1.locked-ether.json | 1 + .../locked_ether.locked-ether.json | 1 + .../low_level_calls.low-level-calls.json | 1 + .../multiple_calls_in_loop.calls-loop.json | 1 + .../naming_convention.naming-convention.json | 12 ++++++++ .../old_solc.sol.json.solc-version.json | 1 + tests/expected_json/pragma.0.4.24.pragma.json | 1 + .../reentrancy-0.5.1.reentrancy-eth.json | 2 ++ .../reentrancy.reentrancy-eth.json | 2 ++ .../right_to_left_override.rtlo.json | 1 + ...shadowing_abstract.shadowing-abstract.json | 1 + ...ing_builtin_symbols.shadowing-builtin.json | 13 +++++++++ ...dowing_local_variable.shadowing-local.json | 5 ++++ ...dowing_state_variable.shadowing-state.json | 1 + .../solc_version_incorrect.solc-version.json | 2 ++ ...on_incorrect_05.ast.json.solc-version.json | 2 ++ tests/expected_json/timestamp.timestamp.json | 3 ++ .../too_many_digits.too-many-digits.json | 5 ++++ .../tx_origin-0.5.1.tx-origin.json | 2 ++ tests/expected_json/tx_origin.tx-origin.json | 2 ++ ...ked_lowlevel-0.5.1.unchecked-lowlevel.json | 1 + ...unchecked_lowlevel.unchecked-lowlevel.json | 1 + .../unchecked_send-0.5.1.unchecked-send.json | 1 + ...initialized-0.5.1.uninitialized-state.json | 4 +++ .../uninitialized.uninitialized-state.json | 4 +++ ...ed_local_variable.uninitialized-local.json | 1 + ...storage_pointer.uninitialized-storage.json | 1 + .../unused_return.unused-return.json | 2 ++ .../unused_state.unused-state.json | 4 +++ tests/expected_json/void-cst.void-cst.json | 1 + 49 files changed, 177 insertions(+) diff --git a/slither/utils/output.py b/slither/utils/output.py index b9bacd274..d9fb77faf 100644 --- a/slither/utils/output.py +++ b/slither/utils/output.py @@ -1,3 +1,4 @@ +import hashlib import os import json import logging @@ -101,6 +102,31 @@ def _convert_to_markdown(d, markdown_root): raise SlitherError(f'{type(d)} cannot be converted (no name, or canonical_name') +def _convert_to_id(d): + ''' + Id keeps the source mapping of the node, otherwise we risk to consider two different node as the same + :param d: + :return: + ''' + if isinstance(d, str): + return d + + if not isinstance(d, SourceMapping): + raise SlitherError(f'{d} does not inherit from SourceMapping, conversion impossible') + + if isinstance(d, Node): + if d.expression: + return f'{d.expression} ({d.source_mapping_str})' + else: + return f'{str(d)} ({d.source_mapping_str})' + + if hasattr(d, 'canonical_name'): + return f'{d.canonical_name}' + + if hasattr(d, 'name'): + return f'{d.name}' + + raise SlitherError(f'{type(d)} cannot be converted (no name, or canonical_name') # endregion ################################################################################### @@ -160,6 +186,9 @@ class Output: self._data['elements'] = [] self._data['description'] = ''.join(_convert_to_description(d) for d in info) self._data['markdown'] = ''.join(_convert_to_markdown(d, markdown_root) for d in info) + + id_txt = ''.join(_convert_to_id(d) for d in info) + self._data['id'] = hashlib.sha3_256(id_txt.encode('utf-8')).hexdigest() if standard_format: to_add = [i for i in info if not isinstance(i, str)] diff --git a/tests/expected_json/arbitrary_send-0.5.1.arbitrary-send.json b/tests/expected_json/arbitrary_send-0.5.1.arbitrary-send.json index 09c8fb7b9..fb337f7ce 100644 --- a/tests/expected_json/arbitrary_send-0.5.1.arbitrary-send.json +++ b/tests/expected_json/arbitrary_send-0.5.1.arbitrary-send.json @@ -190,6 +190,7 @@ ], "description": "Test.direct() (tests/arbitrary_send-0.5.1.sol#11-13) sends eth to arbitrary user\n\tDangerous calls:\n\t- msg.sender.send(address(this).balance) (tests/arbitrary_send-0.5.1.sol#12)\n", "markdown": "[Test.direct()](tests/arbitrary_send-0.5.1.sol#L11-L13) sends eth to arbitrary user\n\tDangerous calls:\n\t- [msg.sender.send(address(this).balance)](tests/arbitrary_send-0.5.1.sol#L12)\n", + "id": "5479aabac8e802dcfc47713305fe8ed8d58001b9891d028dd9e4d61d5b2a3a3e", "check": "arbitrary-send", "impact": "High", "confidence": "Medium" @@ -381,6 +382,7 @@ ], "description": "Test.indirect() (tests/arbitrary_send-0.5.1.sol#19-21) sends eth to arbitrary user\n\tDangerous calls:\n\t- destination.send(address(this).balance) (tests/arbitrary_send-0.5.1.sol#20)\n", "markdown": "[Test.indirect()](tests/arbitrary_send-0.5.1.sol#L19-L21) sends eth to arbitrary user\n\tDangerous calls:\n\t- [destination.send(address(this).balance)](tests/arbitrary_send-0.5.1.sol#L20)\n", + "id": "94e4360762e1ecac015c1c6cc6045bb0b0599cb576aa64dd0f9b5554631607a6", "check": "arbitrary-send", "impact": "High", "confidence": "Medium" diff --git a/tests/expected_json/arbitrary_send.arbitrary-send.json b/tests/expected_json/arbitrary_send.arbitrary-send.json index 1d6122843..3a35743ae 100644 --- a/tests/expected_json/arbitrary_send.arbitrary-send.json +++ b/tests/expected_json/arbitrary_send.arbitrary-send.json @@ -190,6 +190,7 @@ ], "description": "Test.direct() (tests/arbitrary_send.sol#11-13) sends eth to arbitrary user\n\tDangerous calls:\n\t- msg.sender.send(address(this).balance) (tests/arbitrary_send.sol#12)\n", "markdown": "[Test.direct()](tests/arbitrary_send.sol#L11-L13) sends eth to arbitrary user\n\tDangerous calls:\n\t- [msg.sender.send(address(this).balance)](tests/arbitrary_send.sol#L12)\n", + "id": "db62976d0c290f0b09f4df06f97bf2921c4d7ee734eb086b5f1a619f3583d83b", "check": "arbitrary-send", "impact": "High", "confidence": "Medium" @@ -381,6 +382,7 @@ ], "description": "Test.indirect() (tests/arbitrary_send.sol#19-21) sends eth to arbitrary user\n\tDangerous calls:\n\t- destination.send(address(this).balance) (tests/arbitrary_send.sol#20)\n", "markdown": "[Test.indirect()](tests/arbitrary_send.sol#L19-L21) sends eth to arbitrary user\n\tDangerous calls:\n\t- [destination.send(address(this).balance)](tests/arbitrary_send.sol#L20)\n", + "id": "643af1938b9f04e949e0ccaffd907915b3ed93652671e3f5613e8b5f3ceef2bf", "check": "arbitrary-send", "impact": "High", "confidence": "Medium" diff --git a/tests/expected_json/backdoor.backdoor.json b/tests/expected_json/backdoor.backdoor.json index beae48a85..4af157e1e 100644 --- a/tests/expected_json/backdoor.backdoor.json +++ b/tests/expected_json/backdoor.backdoor.json @@ -55,6 +55,7 @@ ], "description": "Backdoor function found in C.i_am_a_backdoor() (tests/backdoor.sol#4-6)\n", "markdown": "Backdoor function found in [C.i_am_a_backdoor()](tests/backdoor.sol#L4-L6)\n", + "id": "8a9008f2f5cd23b34feb0235dcc30ecb8d09a10eff151b522939caead117ef7a", "check": "backdoor", "impact": "High", "confidence": "High" diff --git a/tests/expected_json/backdoor.suicidal.json b/tests/expected_json/backdoor.suicidal.json index ae632e1dc..5bce85de7 100644 --- a/tests/expected_json/backdoor.suicidal.json +++ b/tests/expected_json/backdoor.suicidal.json @@ -55,6 +55,7 @@ ], "description": "C.i_am_a_backdoor() (tests/backdoor.sol#4-6) allows anyone to destruct the contract\n", "markdown": "[C.i_am_a_backdoor()](tests/backdoor.sol#L4-L6) allows anyone to destruct the contract\n", + "id": "bb1e4596537b6e2c29f4221e733692fd6dac8555095181718e440ca525016eb7", "check": "suicidal", "impact": "High", "confidence": "High" diff --git a/tests/expected_json/const_state_variables.constable-states.json b/tests/expected_json/const_state_variables.constable-states.json index 5864c1e07..0acef53d6 100644 --- a/tests/expected_json/const_state_variables.constable-states.json +++ b/tests/expected_json/const_state_variables.constable-states.json @@ -63,6 +63,7 @@ ], "description": "A.myFriendsAddress (tests/const_state_variables.sol#7) should be constant\n", "markdown": "[A.myFriendsAddress](tests/const_state_variables.sol#L7) should be constant\n", + "id": "1454db80653b732bf6acbe54ff0ae4707002207a2a8216708c12d61c88a43e5f", "check": "constable-states", "impact": "Optimization", "confidence": "High" @@ -127,6 +128,7 @@ ], "description": "A.test (tests/const_state_variables.sol#10) should be constant\n", "markdown": "[A.test](tests/const_state_variables.sol#L10) should be constant\n", + "id": "5d9e3fb413322b71a93e90f7e89bd8c83cd4884d577d039598c681fe9db38b1d", "check": "constable-states", "impact": "Optimization", "confidence": "High" @@ -191,6 +193,7 @@ ], "description": "A.text2 (tests/const_state_variables.sol#14) should be constant\n", "markdown": "[A.text2](tests/const_state_variables.sol#L14) should be constant\n", + "id": "df11e6201c4558a8c5cd90b55b134b9ca8f07203b2264d3aa93bd7745e8cb4ba", "check": "constable-states", "impact": "Optimization", "confidence": "High" @@ -251,6 +254,7 @@ ], "description": "B.mySistersAddress (tests/const_state_variables.sol#26) should be constant\n", "markdown": "[B.mySistersAddress](tests/const_state_variables.sol#L26) should be constant\n", + "id": "bee93a722c8eae4a48aade67d8ef537d84c106f48fc9eb738c795fce10d3bc63", "check": "constable-states", "impact": "Optimization", "confidence": "High" @@ -311,6 +315,7 @@ ], "description": "MyConc.should_be_constant (tests/const_state_variables.sol#42) should be constant\n", "markdown": "[MyConc.should_be_constant](tests/const_state_variables.sol#L42) should be constant\n", + "id": "cbcafa2a3efba4d21ac1b51b4b823e5082d556bc3d6cf3fd2ab3188f9f218fc1", "check": "constable-states", "impact": "Optimization", "confidence": "High" @@ -371,6 +376,7 @@ ], "description": "MyConc.should_be_constant_2 (tests/const_state_variables.sol#43) should be constant\n", "markdown": "[MyConc.should_be_constant_2](tests/const_state_variables.sol#L43) should be constant\n", + "id": "9a48a4122de1a6a4774a9f1e0d4917bd0fa08f17b4af41b86ba07689e51bf711", "check": "constable-states", "impact": "Optimization", "confidence": "High" diff --git a/tests/expected_json/constant-0.5.1.constant-function.json b/tests/expected_json/constant-0.5.1.constant-function.json index 158cd404d..dab6537ea 100644 --- a/tests/expected_json/constant-0.5.1.constant-function.json +++ b/tests/expected_json/constant-0.5.1.constant-function.json @@ -66,6 +66,7 @@ ], "description": "Constant.test_assembly_bug() (tests/constant-0.5.1.sol#15-17) is declared view but contains assembly code\n", "markdown": "[Constant.test_assembly_bug()](tests/constant-0.5.1.sol#L15-L17) is declared view but contains assembly code\n", + "id": "1f892cae08b89096bdc4d6ecdf55a3adc4b4314390e054fe2547d9c8e9f76e23", "additional_fields": { "contains_assembly": true }, diff --git a/tests/expected_json/constant.constant-function.json b/tests/expected_json/constant.constant-function.json index a15771900..40c0c626e 100644 --- a/tests/expected_json/constant.constant-function.json +++ b/tests/expected_json/constant.constant-function.json @@ -135,6 +135,7 @@ ], "description": "Constant.test_view_bug() (tests/constant.sol#5-7) is declared view but changes state variables:\n\t- Constant.a (tests/constant.sol#3)\n", "markdown": "[Constant.test_view_bug()](tests/constant.sol#L5-L7) is declared view but changes state variables:\n\t- [Constant.a](tests/constant.sol#L3)\n", + "id": "4dee61d8835d20c6f1f7c195d8bd1e9de5dbcc096396a5b8db391136f9f5fdf1", "additional_fields": { "contains_assembly": false }, @@ -274,6 +275,7 @@ ], "description": "Constant.test_constant_bug() (tests/constant.sol#9-11) is declared view but changes state variables:\n\t- Constant.a (tests/constant.sol#3)\n", "markdown": "[Constant.test_constant_bug()](tests/constant.sol#L9-L11) is declared view but changes state variables:\n\t- [Constant.a](tests/constant.sol#L3)\n", + "id": "145e2d34dfc5b932c8d67d480c0eaec9baa8c728e2a310529572c0c4a5c6046a", "additional_fields": { "contains_assembly": false }, @@ -351,6 +353,7 @@ ], "description": "Constant.test_assembly_bug() (tests/constant.sol#22-24) is declared view but contains assembly code\n", "markdown": "[Constant.test_assembly_bug()](tests/constant.sol#L22-L24) is declared view but contains assembly code\n", + "id": "1f892cae08b89096bdc4d6ecdf55a3adc4b4314390e054fe2547d9c8e9f76e23", "additional_fields": { "contains_assembly": true }, diff --git a/tests/expected_json/controlled_delegatecall.controlled-delegatecall.json b/tests/expected_json/controlled_delegatecall.controlled-delegatecall.json index 1f2c9bf9c..1f0265c35 100644 --- a/tests/expected_json/controlled_delegatecall.controlled-delegatecall.json +++ b/tests/expected_json/controlled_delegatecall.controlled-delegatecall.json @@ -160,6 +160,7 @@ ], "description": "C.bad_delegate_call(bytes) (tests/controlled_delegatecall.sol#8-11) uses delegatecall to a input-controlled function id\n\t- addr_bad.delegatecall(data) (tests/controlled_delegatecall.sol#10)\n", "markdown": "[C.bad_delegate_call(bytes)](tests/controlled_delegatecall.sol#L8-L11) uses delegatecall to a input-controlled function id\n\t- [addr_bad.delegatecall(data)](tests/controlled_delegatecall.sol#L10)\n", + "id": "a97990bb03ea7d6b3844cfe53689f9d3f32e49baf83e603760588e34c7cba64f", "check": "controlled-delegatecall", "impact": "High", "confidence": "Medium" @@ -319,6 +320,7 @@ ], "description": "C.bad_delegate_call2(bytes) (tests/controlled_delegatecall.sol#18-20) uses delegatecall to a input-controlled function id\n\t- addr_bad.delegatecall(abi.encode(func_id,data)) (tests/controlled_delegatecall.sol#19)\n", "markdown": "[C.bad_delegate_call2(bytes)](tests/controlled_delegatecall.sol#L18-L20) uses delegatecall to a input-controlled function id\n\t- [addr_bad.delegatecall(abi.encode(func_id,data))](tests/controlled_delegatecall.sol#L19)\n", + "id": "611ca2baf5d14852abb16f98b888d9d52760b8e729599d472c669a9b2f008026", "check": "controlled-delegatecall", "impact": "High", "confidence": "Medium" diff --git a/tests/expected_json/deprecated_calls.deprecated-standards.json b/tests/expected_json/deprecated_calls.deprecated-standards.json index c318914ac..a071350b7 100644 --- a/tests/expected_json/deprecated_calls.deprecated-standards.json +++ b/tests/expected_json/deprecated_calls.deprecated-standards.json @@ -72,6 +72,7 @@ ], "description": "Deprecated standard detected ContractWithDeprecatedReferences.globalBlockHash (tests/deprecated_calls.sol#2):\n\t- Usage of \"block.blockhash()\" should be replaced with \"blockhash()\"\n", "markdown": "Deprecated standard detected [ContractWithDeprecatedReferences.globalBlockHash](tests/deprecated_calls.sol#L2):\n\t- Usage of \"block.blockhash()\" should be replaced with \"blockhash()\"\n", + "id": "84ecc7e9ce51f3a7103d3674e237fe1ba07899cca5d40de91172c36f434fc9ce", "check": "deprecated-standards", "impact": "Informational", "confidence": "High" @@ -172,6 +173,7 @@ ], "description": "Deprecated standard detected msg.gas == msg.value (tests/deprecated_calls.sol#7):\n\t- Usage of \"msg.gas\" should be replaced with \"gasleft()\"\n", "markdown": "Deprecated standard detected [msg.gas == msg.value](tests/deprecated_calls.sol#L7):\n\t- Usage of \"msg.gas\" should be replaced with \"gasleft()\"\n", + "id": "0af1a05682eb2ab89143849898f6e2fb9bdfa6bdd01d43d81d41e10c4dfe58d7", "check": "deprecated-standards", "impact": "Informational", "confidence": "High" @@ -272,6 +274,7 @@ ], "description": "Deprecated standard detected THROW None (tests/deprecated_calls.sol#9):\n\t- Usage of \"throw\" should be replaced with \"revert()\"\n", "markdown": "Deprecated standard detected [THROW None](tests/deprecated_calls.sol#L9):\n\t- Usage of \"throw\" should be replaced with \"revert()\"\n", + "id": "1a3241d58683640c33ae9e1bcd65bafd7472e7b7c9d2ec695f84590a2cef286a", "check": "deprecated-standards", "impact": "Informational", "confidence": "High" @@ -378,6 +381,7 @@ ], "description": "Deprecated standard detected sha3Result = sha3()(test deprecated sha3 usage) (tests/deprecated_calls.sol#16):\n\t- Usage of \"sha3()\" should be replaced with \"keccak256()\"\n", "markdown": "Deprecated standard detected [sha3Result = sha3()(test deprecated sha3 usage)](tests/deprecated_calls.sol#L16):\n\t- Usage of \"sha3()\" should be replaced with \"keccak256()\"\n", + "id": "3926d80bb1119eb9faf7abdf2c2b61ce7accc5bcf4c0eaed120910e6662891f3", "check": "deprecated-standards", "impact": "Informational", "confidence": "High" @@ -484,6 +488,7 @@ ], "description": "Deprecated standard detected blockHashResult = block.blockhash(0) (tests/deprecated_calls.sol#19):\n\t- Usage of \"block.blockhash()\" should be replaced with \"blockhash()\"\n", "markdown": "Deprecated standard detected [blockHashResult = block.blockhash(0)](tests/deprecated_calls.sol#L19):\n\t- Usage of \"block.blockhash()\" should be replaced with \"blockhash()\"\n", + "id": "0e462458439683a8a7a6d2113e962b00bb79ead8d7f6f462a158cf114bd22e96", "check": "deprecated-standards", "impact": "Informational", "confidence": "High" @@ -590,6 +595,7 @@ ], "description": "Deprecated standard detected address(this).callcode() (tests/deprecated_calls.sol#22):\n\t- Usage of \"callcode\" should be replaced with \"delegatecall\"\n", "markdown": "Deprecated standard detected [address(this).callcode()](tests/deprecated_calls.sol#L22):\n\t- Usage of \"callcode\" should be replaced with \"delegatecall\"\n", + "id": "8d21d721e732845b6a72e96498c98f07a214f4acfb2f956a93dc48b57ed5de95", "check": "deprecated-standards", "impact": "Informational", "confidence": "High" @@ -696,6 +702,7 @@ ], "description": "Deprecated standard detected suicide(address)(address(0)) (tests/deprecated_calls.sol#25):\n\t- Usage of \"suicide()\" should be replaced with \"selfdestruct()\"\n", "markdown": "Deprecated standard detected [suicide(address)(address(0))](tests/deprecated_calls.sol#L25):\n\t- Usage of \"suicide()\" should be replaced with \"selfdestruct()\"\n", + "id": "741bd57823d2933e7f19c5bebab1a57506f0fd377e148ae9383c2b40ca768508", "check": "deprecated-standards", "impact": "Informational", "confidence": "High" @@ -816,6 +823,7 @@ ], "description": "Deprecated standard detected globalBlockHash = block.blockhash(0) (tests/deprecated_calls.sol#2):\n\t- Usage of \"block.blockhash()\" should be replaced with \"blockhash()\"\n", "markdown": "Deprecated standard detected [globalBlockHash = block.blockhash(0)](tests/deprecated_calls.sol#L2):\n\t- Usage of \"block.blockhash()\" should be replaced with \"blockhash()\"\n", + "id": "1a17fcbea6521ac0d23bbae6d75bcb85c6ba345a57e976e9e3a8d7862bbd9773", "check": "deprecated-standards", "impact": "Informational", "confidence": "High" diff --git a/tests/expected_json/erc20_indexed.erc20-indexed.json b/tests/expected_json/erc20_indexed.erc20-indexed.json index 3aeaf30a9..431d70da5 100644 --- a/tests/expected_json/erc20_indexed.erc20-indexed.json +++ b/tests/expected_json/erc20_indexed.erc20-indexed.json @@ -59,6 +59,7 @@ ], "description": "ERC20 event IERC20BadTransfer(address,address,uint256) (tests/erc20_indexed.sol#19)does not index parameter from\n", "markdown": "ERC20 event [IERC20BadTransfer(address,address,uint256)](tests/erc20_indexed.sol#L19)does not index parameter from\n", + "id": "a86c7a54115f270548e82d71570dc4d2900b622b0f82c6fce137f3a35314af53", "check": "erc20-indexed", "impact": "Informational", "confidence": "High" @@ -119,6 +120,7 @@ ], "description": "ERC20 event IERC20BadTransfer(address,address,uint256) (tests/erc20_indexed.sol#19)does not index parameter to\n", "markdown": "ERC20 event [IERC20BadTransfer(address,address,uint256)](tests/erc20_indexed.sol#L19)does not index parameter to\n", + "id": "29c46eb3a4695004959847ae09377729cdf3aa583de95560090b9bd49977c49b", "check": "erc20-indexed", "impact": "Informational", "confidence": "High" @@ -179,6 +181,7 @@ ], "description": "ERC20 event IERC20BadApproval(address,address,uint256) (tests/erc20_indexed.sol#20)does not index parameter owner\n", "markdown": "ERC20 event [IERC20BadApproval(address,address,uint256)](tests/erc20_indexed.sol#L20)does not index parameter owner\n", + "id": "7d72b56a71ca96db304878f25484c496af1d283a9b777dc788f1473974057025", "check": "erc20-indexed", "impact": "Informational", "confidence": "High" @@ -239,6 +242,7 @@ ], "description": "ERC20 event IERC20BadApproval(address,address,uint256) (tests/erc20_indexed.sol#20)does not index parameter spender\n", "markdown": "ERC20 event [IERC20BadApproval(address,address,uint256)](tests/erc20_indexed.sol#L20)does not index parameter spender\n", + "id": "df4d927d202bdca1fc411d6960d3f62ed2784f5eca7435cb0503f4154f2e3bc6", "check": "erc20-indexed", "impact": "Informational", "confidence": "High" diff --git a/tests/expected_json/external_function.external-function.json b/tests/expected_json/external_function.external-function.json index 2e1fa666c..fa3214e2b 100644 --- a/tests/expected_json/external_function.external-function.json +++ b/tests/expected_json/external_function.external-function.json @@ -67,6 +67,7 @@ ], "description": "funcNotCalled3() should be declared external:\n\t- ContractWithFunctionNotCalled.funcNotCalled3() (tests/external_function.sol#13-15)\n", "markdown": "funcNotCalled3() should be declared external:\n\t- [ContractWithFunctionNotCalled.funcNotCalled3()](tests/external_function.sol#L13-L15)\n", + "id": "026d9a579ea0304e58c8a5174296494f4b672e4ea032f4e17504f3dac327c4e6", "check": "external-function", "impact": "Optimization", "confidence": "High" @@ -135,6 +136,7 @@ ], "description": "funcNotCalled2() should be declared external:\n\t- ContractWithFunctionNotCalled.funcNotCalled2() (tests/external_function.sol#17-19)\n", "markdown": "funcNotCalled2() should be declared external:\n\t- [ContractWithFunctionNotCalled.funcNotCalled2()](tests/external_function.sol#L17-L19)\n", + "id": "1ef1f19a92a8ab8d27df156d50dd75628ec3057b5f5eb16b7d1faa0e5c3850a0", "check": "external-function", "impact": "Optimization", "confidence": "High" @@ -203,6 +205,7 @@ ], "description": "funcNotCalled() should be declared external:\n\t- ContractWithFunctionNotCalled.funcNotCalled() (tests/external_function.sol#21-23)\n", "markdown": "funcNotCalled() should be declared external:\n\t- [ContractWithFunctionNotCalled.funcNotCalled()](tests/external_function.sol#L21-L23)\n", + "id": "369a2f3d071735755ff4f5bc43081fe858bbfb07eed94e5c6dda3c8daa22ba26", "check": "external-function", "impact": "Optimization", "confidence": "High" @@ -267,6 +270,7 @@ ], "description": "funcNotCalled() should be declared external:\n\t- ContractWithFunctionNotCalled2.funcNotCalled() (tests/external_function.sol#32-39)\n", "markdown": "funcNotCalled() should be declared external:\n\t- [ContractWithFunctionNotCalled2.funcNotCalled()](tests/external_function.sol#L32-L39)\n", + "id": "80a0a3a3954cc6e314079a1d8d96d6739d521ddbcf738e63078d7f210e443562", "check": "external-function", "impact": "Optimization", "confidence": "High" @@ -327,6 +331,7 @@ ], "description": "parameter_read_ok_for_external(uint256) should be declared external:\n\t- FunctionParameterWrite.parameter_read_ok_for_external(uint256) (tests/external_function.sol#74-76)\n", "markdown": "parameter_read_ok_for_external(uint256) should be declared external:\n\t- [FunctionParameterWrite.parameter_read_ok_for_external(uint256)](tests/external_function.sol#L74-L76)\n", + "id": "3a0a42d128eff9fb04d8f7605bf2d6f7574c2cbbdffa2dcabbae66d7568ecc59", "check": "external-function", "impact": "Optimization", "confidence": "High" diff --git a/tests/expected_json/incorrect_equality.incorrect-equality.json b/tests/expected_json/incorrect_equality.incorrect-equality.json index bf26037cf..2f5b0723d 100644 --- a/tests/expected_json/incorrect_equality.incorrect-equality.json +++ b/tests/expected_json/incorrect_equality.incorrect-equality.json @@ -146,6 +146,7 @@ ], "description": "ERC20TestBalance.bad0(ERC20Function) (tests/incorrect_equality.sol#21-23) uses a dangerous strict equality:\n\t- require(bool)(erc.balanceOf(address(this)) == 10) (tests/incorrect_equality.sol#22)\n", "markdown": "[ERC20TestBalance.bad0(ERC20Function)](tests/incorrect_equality.sol#L21-L23) uses a dangerous strict equality:\n\t- [require(bool)(erc.balanceOf(address(this)) == 10)](tests/incorrect_equality.sol#L22)\n", + "id": "75aa0ac0f7038b6a92030dee5c4c8f4cc6ab3f491558e18c61b6db5fbbf971e4", "check": "incorrect-equality", "impact": "Medium", "confidence": "High" @@ -293,6 +294,7 @@ ], "description": "ERC20TestBalance.bad1(ERC20Variable) (tests/incorrect_equality.sol#25-27) uses a dangerous strict equality:\n\t- require(bool)(erc.balanceOf(msg.sender) == 10) (tests/incorrect_equality.sol#26)\n", "markdown": "[ERC20TestBalance.bad1(ERC20Variable)](tests/incorrect_equality.sol#L25-L27) uses a dangerous strict equality:\n\t- [require(bool)(erc.balanceOf(msg.sender) == 10)](tests/incorrect_equality.sol#L26)\n", + "id": "747d47c020b94e00fa06cc310b205306c37fda3811bafde5ee820ff84656127e", "check": "incorrect-equality", "impact": "Medium", "confidence": "High" @@ -540,6 +542,7 @@ ], "description": "TestContractBalance.bad0() (tests/incorrect_equality.sol#32-35) uses a dangerous strict equality:\n\t- require(bool)(address(address(this)).balance == 10000000000000000000) (tests/incorrect_equality.sol#33)\n", "markdown": "[TestContractBalance.bad0()](tests/incorrect_equality.sol#L32-L35) uses a dangerous strict equality:\n\t- [require(bool)(address(address(this)).balance == 10000000000000000000)](tests/incorrect_equality.sol#L33)\n", + "id": "90491e5c72bcd00b473b5d5748a62145c1c156d5805735ee893953595c144f7b", "check": "incorrect-equality", "impact": "Medium", "confidence": "High" @@ -787,6 +790,7 @@ ], "description": "TestContractBalance.bad1() (tests/incorrect_equality.sol#37-40) uses a dangerous strict equality:\n\t- require(bool)(10000000000000000000 == address(address(this)).balance) (tests/incorrect_equality.sol#38)\n", "markdown": "[TestContractBalance.bad1()](tests/incorrect_equality.sol#L37-L40) uses a dangerous strict equality:\n\t- [require(bool)(10000000000000000000 == address(address(this)).balance)](tests/incorrect_equality.sol#L38)\n", + "id": "1931d5770ec78d317bd036dc509a5f9914db54236e9ae451204efc17559396cb", "check": "incorrect-equality", "impact": "Medium", "confidence": "High" @@ -1034,6 +1038,7 @@ ], "description": "TestContractBalance.bad2() (tests/incorrect_equality.sol#42-45) uses a dangerous strict equality:\n\t- require(bool)(address(this).balance == 10000000000000000000) (tests/incorrect_equality.sol#43)\n", "markdown": "[TestContractBalance.bad2()](tests/incorrect_equality.sol#L42-L45) uses a dangerous strict equality:\n\t- [require(bool)(address(this).balance == 10000000000000000000)](tests/incorrect_equality.sol#L43)\n", + "id": "55f882e1ab114a792fce75d5cce66a3213ac069aa7cbb5625ca5623eb20171a0", "check": "incorrect-equality", "impact": "Medium", "confidence": "High" @@ -1281,6 +1286,7 @@ ], "description": "TestContractBalance.bad3() (tests/incorrect_equality.sol#47-50) uses a dangerous strict equality:\n\t- require(bool)(10000000000000000000 == address(this).balance) (tests/incorrect_equality.sol#48)\n", "markdown": "[TestContractBalance.bad3()](tests/incorrect_equality.sol#L47-L50) uses a dangerous strict equality:\n\t- [require(bool)(10000000000000000000 == address(this).balance)](tests/incorrect_equality.sol#L48)\n", + "id": "0f6f6872f53fd271e9a246cb5d6bbe56cdeb34df832f28844dd1e758d1ea8e20", "check": "incorrect-equality", "impact": "Medium", "confidence": "High" @@ -1532,6 +1538,7 @@ ], "description": "TestContractBalance.bad4() (tests/incorrect_equality.sol#52-57) uses a dangerous strict equality:\n\t- balance == 10000000000000000000 (tests/incorrect_equality.sol#54)\n", "markdown": "[TestContractBalance.bad4()](tests/incorrect_equality.sol#L52-L57) uses a dangerous strict equality:\n\t- [balance == 10000000000000000000](tests/incorrect_equality.sol#L54)\n", + "id": "10a836ebf912b1c384df149242be6ac888bd7739ab7b0e28e20221665a35dc1b", "check": "incorrect-equality", "impact": "Medium", "confidence": "High" @@ -1783,6 +1790,7 @@ ], "description": "TestContractBalance.bad5() (tests/incorrect_equality.sol#59-64) uses a dangerous strict equality:\n\t- 10000000000000000000 == balance (tests/incorrect_equality.sol#61)\n", "markdown": "[TestContractBalance.bad5()](tests/incorrect_equality.sol#L59-L64) uses a dangerous strict equality:\n\t- [10000000000000000000 == balance](tests/incorrect_equality.sol#L61)\n", + "id": "627eca9af27adf553a7508940ba1f8985ab374b291311fab8ca51db936af8a45", "check": "incorrect-equality", "impact": "Medium", "confidence": "High" @@ -2034,6 +2042,7 @@ ], "description": "TestContractBalance.bad6() (tests/incorrect_equality.sol#66-71) uses a dangerous strict equality:\n\t- balance == 10000000000000000000 (tests/incorrect_equality.sol#68)\n", "markdown": "[TestContractBalance.bad6()](tests/incorrect_equality.sol#L66-L71) uses a dangerous strict equality:\n\t- [balance == 10000000000000000000](tests/incorrect_equality.sol#L68)\n", + "id": "76e879b9ffe8cbfbecfe665508a4e826d2f7a1276895e72df3c027f8e7d48dc5", "check": "incorrect-equality", "impact": "Medium", "confidence": "High" @@ -2217,6 +2226,7 @@ ], "description": "TestSolidityKeyword.bad0() (tests/incorrect_equality.sol#123-125) uses a dangerous strict equality:\n\t- require(bool)(now == 0) (tests/incorrect_equality.sol#124)\n", "markdown": "[TestSolidityKeyword.bad0()](tests/incorrect_equality.sol#L123-L125) uses a dangerous strict equality:\n\t- [require(bool)(now == 0)](tests/incorrect_equality.sol#L124)\n", + "id": "e1a99aa0ace22569091c55b4b2c0d5f6b2650aa86a5e65aba3c7fa75ab50c5e9", "check": "incorrect-equality", "impact": "Medium", "confidence": "High" @@ -2400,6 +2410,7 @@ ], "description": "TestSolidityKeyword.bad1() (tests/incorrect_equality.sol#127-129) uses a dangerous strict equality:\n\t- require(bool)(block.number == 0) (tests/incorrect_equality.sol#128)\n", "markdown": "[TestSolidityKeyword.bad1()](tests/incorrect_equality.sol#L127-L129) uses a dangerous strict equality:\n\t- [require(bool)(block.number == 0)](tests/incorrect_equality.sol#L128)\n", + "id": "554e3fc05ff46a0c04a7a239f3ed04926fd3506208c5badaaebb1dc4ba8ef13a", "check": "incorrect-equality", "impact": "Medium", "confidence": "High" @@ -2583,6 +2594,7 @@ ], "description": "TestSolidityKeyword.bad2() (tests/incorrect_equality.sol#131-133) uses a dangerous strict equality:\n\t- require(bool)(block.number == 0) (tests/incorrect_equality.sol#132)\n", "markdown": "[TestSolidityKeyword.bad2()](tests/incorrect_equality.sol#L131-L133) uses a dangerous strict equality:\n\t- [require(bool)(block.number == 0)](tests/incorrect_equality.sol#L132)\n", + "id": "820ed197f8fa55086981bdcc258e50464c75815e1ec873a426297361ad32e1d8", "check": "incorrect-equality", "impact": "Medium", "confidence": "High" diff --git a/tests/expected_json/incorrect_erc20_interface.erc20-interface.json b/tests/expected_json/incorrect_erc20_interface.erc20-interface.json index b5a9e0ef8..a3a58db0e 100644 --- a/tests/expected_json/incorrect_erc20_interface.erc20-interface.json +++ b/tests/expected_json/incorrect_erc20_interface.erc20-interface.json @@ -79,6 +79,7 @@ ], "description": "Token (tests/incorrect_erc20_interface.sol#3-10) has incorrect ERC20 function interface:Token.transfer(address,uint256) (tests/incorrect_erc20_interface.sol#4)\n", "markdown": "[Token](tests/incorrect_erc20_interface.sol#L3-L10) has incorrect ERC20 function interface:[Token.transfer(address,uint256)](tests/incorrect_erc20_interface.sol#L4)\n", + "id": "d3df2e48ae6e8a1b05b275de574b480853a0839c272ce889e8a1664ae432698e", "check": "erc20-interface", "impact": "Medium", "confidence": "High" @@ -159,6 +160,7 @@ ], "description": "Token (tests/incorrect_erc20_interface.sol#3-10) has incorrect ERC20 function interface:Token.approve(address,uint256) (tests/incorrect_erc20_interface.sol#5)\n", "markdown": "[Token](tests/incorrect_erc20_interface.sol#L3-L10) has incorrect ERC20 function interface:[Token.approve(address,uint256)](tests/incorrect_erc20_interface.sol#L5)\n", + "id": "0fced3029cf59cf348a6b79c58dbb032d837fdd5a5f355600edebda1878e9e2e", "check": "erc20-interface", "impact": "Medium", "confidence": "High" @@ -239,6 +241,7 @@ ], "description": "Token (tests/incorrect_erc20_interface.sol#3-10) has incorrect ERC20 function interface:Token.transferFrom(address,address,uint256) (tests/incorrect_erc20_interface.sol#6)\n", "markdown": "[Token](tests/incorrect_erc20_interface.sol#L3-L10) has incorrect ERC20 function interface:[Token.transferFrom(address,address,uint256)](tests/incorrect_erc20_interface.sol#L6)\n", + "id": "ba13a1588595032984a3fad39610a2414bb8fcb522d1e632d52fa947ff207d73", "check": "erc20-interface", "impact": "Medium", "confidence": "High" @@ -319,6 +322,7 @@ ], "description": "Token (tests/incorrect_erc20_interface.sol#3-10) has incorrect ERC20 function interface:Token.totalSupply() (tests/incorrect_erc20_interface.sol#7)\n", "markdown": "[Token](tests/incorrect_erc20_interface.sol#L3-L10) has incorrect ERC20 function interface:[Token.totalSupply()](tests/incorrect_erc20_interface.sol#L7)\n", + "id": "c951e429e546af28ac08e241d391e874c1c9c70b0732ccfb63f3bbfb3eaac16e", "check": "erc20-interface", "impact": "Medium", "confidence": "High" @@ -399,6 +403,7 @@ ], "description": "Token (tests/incorrect_erc20_interface.sol#3-10) has incorrect ERC20 function interface:Token.balanceOf(address) (tests/incorrect_erc20_interface.sol#8)\n", "markdown": "[Token](tests/incorrect_erc20_interface.sol#L3-L10) has incorrect ERC20 function interface:[Token.balanceOf(address)](tests/incorrect_erc20_interface.sol#L8)\n", + "id": "758ca2456030a36dbd6115f2ccb1a43f53f1dabd66ed079806df0f6b7b4d21ef", "check": "erc20-interface", "impact": "Medium", "confidence": "High" @@ -479,6 +484,7 @@ ], "description": "Token (tests/incorrect_erc20_interface.sol#3-10) has incorrect ERC20 function interface:Token.allowance(address,address) (tests/incorrect_erc20_interface.sol#9)\n", "markdown": "[Token](tests/incorrect_erc20_interface.sol#L3-L10) has incorrect ERC20 function interface:[Token.allowance(address,address)](tests/incorrect_erc20_interface.sol#L9)\n", + "id": "1286abfe21b09e21e1cec8b991f73664e104fa39f7f4190690ece3af45bc0c7a", "check": "erc20-interface", "impact": "Medium", "confidence": "High" diff --git a/tests/expected_json/incorrect_erc721_interface.erc721-interface.json b/tests/expected_json/incorrect_erc721_interface.erc721-interface.json index 1bc67621f..075eac2a4 100644 --- a/tests/expected_json/incorrect_erc721_interface.erc721-interface.json +++ b/tests/expected_json/incorrect_erc721_interface.erc721-interface.json @@ -77,6 +77,7 @@ ], "description": "Token (tests/incorrect_erc721_interface.sol#6-16) has incorrect ERC721 function interface:IERC165.supportsInterface(bytes4) (tests/incorrect_erc721_interface.sol#4)\n", "markdown": "[Token](tests/incorrect_erc721_interface.sol#L6-L16) has incorrect ERC721 function interface:[IERC165.supportsInterface(bytes4)](tests/incorrect_erc721_interface.sol#L4)\n", + "id": "a8593587ca70c51a9ab827843babec3b3eb7f9a08d76eea1e5528e668f7b291d", "check": "erc721-interface", "impact": "Medium", "confidence": "High" @@ -163,6 +164,7 @@ ], "description": "Token (tests/incorrect_erc721_interface.sol#6-16) has incorrect ERC721 function interface:Token.balanceOf(address) (tests/incorrect_erc721_interface.sol#7)\n", "markdown": "[Token](tests/incorrect_erc721_interface.sol#L6-L16) has incorrect ERC721 function interface:[Token.balanceOf(address)](tests/incorrect_erc721_interface.sol#L7)\n", + "id": "6fb9d0320e0b63e2c70f9844d5bea2be958e73beb6eaa4ccb2323ead0c7ef991", "check": "erc721-interface", "impact": "Medium", "confidence": "High" @@ -249,6 +251,7 @@ ], "description": "Token (tests/incorrect_erc721_interface.sol#6-16) has incorrect ERC721 function interface:Token.ownerOf(uint256) (tests/incorrect_erc721_interface.sol#8)\n", "markdown": "[Token](tests/incorrect_erc721_interface.sol#L6-L16) has incorrect ERC721 function interface:[Token.ownerOf(uint256)](tests/incorrect_erc721_interface.sol#L8)\n", + "id": "7d9235dd4ef8bc29a3b7700597cc1e4efb846377c928e5e50c5f49cb37f288d2", "check": "erc721-interface", "impact": "Medium", "confidence": "High" @@ -335,6 +338,7 @@ ], "description": "Token (tests/incorrect_erc721_interface.sol#6-16) has incorrect ERC721 function interface:Token.safeTransferFrom(address,address,uint256,bytes) (tests/incorrect_erc721_interface.sol#9)\n", "markdown": "[Token](tests/incorrect_erc721_interface.sol#L6-L16) has incorrect ERC721 function interface:[Token.safeTransferFrom(address,address,uint256,bytes)](tests/incorrect_erc721_interface.sol#L9)\n", + "id": "ccec612c4b5db00ab59b766b5dde3f8d3a8c6408ef595ab08bff21628587e2a1", "check": "erc721-interface", "impact": "Medium", "confidence": "High" @@ -421,6 +425,7 @@ ], "description": "Token (tests/incorrect_erc721_interface.sol#6-16) has incorrect ERC721 function interface:Token.safeTransferFrom(address,address,uint256) (tests/incorrect_erc721_interface.sol#10)\n", "markdown": "[Token](tests/incorrect_erc721_interface.sol#L6-L16) has incorrect ERC721 function interface:[Token.safeTransferFrom(address,address,uint256)](tests/incorrect_erc721_interface.sol#L10)\n", + "id": "50ab7b0f39f327ac6deccf3c16b4e6fee1dc249072ac41a4bd485ccf0c12315b", "check": "erc721-interface", "impact": "Medium", "confidence": "High" @@ -507,6 +512,7 @@ ], "description": "Token (tests/incorrect_erc721_interface.sol#6-16) has incorrect ERC721 function interface:Token.transferFrom(address,address,uint256) (tests/incorrect_erc721_interface.sol#11)\n", "markdown": "[Token](tests/incorrect_erc721_interface.sol#L6-L16) has incorrect ERC721 function interface:[Token.transferFrom(address,address,uint256)](tests/incorrect_erc721_interface.sol#L11)\n", + "id": "847b11227f3bfc9b120e0ea573f385a4bbc61c4b7f89f434864612a679b1133e", "check": "erc721-interface", "impact": "Medium", "confidence": "High" @@ -593,6 +599,7 @@ ], "description": "Token (tests/incorrect_erc721_interface.sol#6-16) has incorrect ERC721 function interface:Token.approve(address,uint256) (tests/incorrect_erc721_interface.sol#12)\n", "markdown": "[Token](tests/incorrect_erc721_interface.sol#L6-L16) has incorrect ERC721 function interface:[Token.approve(address,uint256)](tests/incorrect_erc721_interface.sol#L12)\n", + "id": "439c95972d0e084aff057161164b13ab63f85bee31d80b568b7155e58eac4b5d", "check": "erc721-interface", "impact": "Medium", "confidence": "High" @@ -679,6 +686,7 @@ ], "description": "Token (tests/incorrect_erc721_interface.sol#6-16) has incorrect ERC721 function interface:Token.setApprovalForAll(address,bool) (tests/incorrect_erc721_interface.sol#13)\n", "markdown": "[Token](tests/incorrect_erc721_interface.sol#L6-L16) has incorrect ERC721 function interface:[Token.setApprovalForAll(address,bool)](tests/incorrect_erc721_interface.sol#L13)\n", + "id": "b95e9bb000fb073c25fdbd9fff7bf0a3c44e04e70fc1a7da27c94c6b7fb8be40", "check": "erc721-interface", "impact": "Medium", "confidence": "High" @@ -765,6 +773,7 @@ ], "description": "Token (tests/incorrect_erc721_interface.sol#6-16) has incorrect ERC721 function interface:Token.getApproved(uint256) (tests/incorrect_erc721_interface.sol#14)\n", "markdown": "[Token](tests/incorrect_erc721_interface.sol#L6-L16) has incorrect ERC721 function interface:[Token.getApproved(uint256)](tests/incorrect_erc721_interface.sol#L14)\n", + "id": "2dce4891c7abea0fa8a8a20a8b8482e7e1d46d54bfd750701c604d5dadd8b937", "check": "erc721-interface", "impact": "Medium", "confidence": "High" @@ -851,6 +860,7 @@ ], "description": "Token (tests/incorrect_erc721_interface.sol#6-16) has incorrect ERC721 function interface:Token.isApprovedForAll(address,address) (tests/incorrect_erc721_interface.sol#15)\n", "markdown": "[Token](tests/incorrect_erc721_interface.sol#L6-L16) has incorrect ERC721 function interface:[Token.isApprovedForAll(address,address)](tests/incorrect_erc721_interface.sol#L15)\n", + "id": "fa9985c505689f9a45d1ac51e1dd8cf79eeb2c939946abfb5ac78f46e692d0eb", "check": "erc721-interface", "impact": "Medium", "confidence": "High" diff --git a/tests/expected_json/inline_assembly_contract-0.5.1.assembly.json b/tests/expected_json/inline_assembly_contract-0.5.1.assembly.json index 8ec3e0312..6e8fddd29 100644 --- a/tests/expected_json/inline_assembly_contract-0.5.1.assembly.json +++ b/tests/expected_json/inline_assembly_contract-0.5.1.assembly.json @@ -179,6 +179,7 @@ ], "description": "GetCode.at(address) (tests/inline_assembly_contract-0.5.1.sol#6-20) uses assembly\n\t- INLINE ASM None (tests/inline_assembly_contract-0.5.1.sol#7-20)\n", "markdown": "[GetCode.at(address)](tests/inline_assembly_contract-0.5.1.sol#L6-L20) uses assembly\n\t- [INLINE ASM None](tests/inline_assembly_contract-0.5.1.sol#L7-L20)\n", + "id": "8f8a296feb87f8865449404161841580a3bb405864ed5f2622fdffdbe6a93ad8", "check": "assembly", "impact": "Informational", "confidence": "High" diff --git a/tests/expected_json/inline_assembly_contract.assembly.json b/tests/expected_json/inline_assembly_contract.assembly.json index 841fb9aa3..333d9a94c 100644 --- a/tests/expected_json/inline_assembly_contract.assembly.json +++ b/tests/expected_json/inline_assembly_contract.assembly.json @@ -179,6 +179,7 @@ ], "description": "GetCode.at(address) (tests/inline_assembly_contract.sol#6-20) uses assembly\n\t- INLINE ASM None (tests/inline_assembly_contract.sol#7-20)\n", "markdown": "[GetCode.at(address)](tests/inline_assembly_contract.sol#L6-L20) uses assembly\n\t- [INLINE ASM None](tests/inline_assembly_contract.sol#L7-L20)\n", + "id": "8f448cbd104ddfcc1c099119fcb367b581476208f7cc3ab5897f4a9b5b4a9080", "check": "assembly", "impact": "Informational", "confidence": "High" diff --git a/tests/expected_json/inline_assembly_library-0.5.1.assembly.json b/tests/expected_json/inline_assembly_library-0.5.1.assembly.json index f027b15b9..db8469ec5 100644 --- a/tests/expected_json/inline_assembly_library-0.5.1.assembly.json +++ b/tests/expected_json/inline_assembly_library-0.5.1.assembly.json @@ -207,6 +207,7 @@ ], "description": "VectorSum.sumAsm(uint256[]) (tests/inline_assembly_library-0.5.1.sol#16-22) uses assembly\n\t- INLINE ASM None (tests/inline_assembly_library-0.5.1.sol#18-21)\n", "markdown": "[VectorSum.sumAsm(uint256[])](tests/inline_assembly_library-0.5.1.sol#L16-L22) uses assembly\n\t- [INLINE ASM None](tests/inline_assembly_library-0.5.1.sol#L18-L21)\n", + "id": "2d646463bf10753d2433783ea4a212d84dfb51269bb062f4ea5db21bd8ec6cb6", "check": "assembly", "impact": "Informational", "confidence": "High" @@ -465,6 +466,7 @@ ], "description": "VectorSum.sumPureAsm(uint256[]) (tests/inline_assembly_library-0.5.1.sol#25-47) uses assembly\n\t- INLINE ASM None (tests/inline_assembly_library-0.5.1.sol#26-47)\n", "markdown": "[VectorSum.sumPureAsm(uint256[])](tests/inline_assembly_library-0.5.1.sol#L25-L47) uses assembly\n\t- [INLINE ASM None](tests/inline_assembly_library-0.5.1.sol#L26-L47)\n", + "id": "df1118184108ae4b7b7300da137ebfc86c3279fcaffabf289d8e79bc23228105", "check": "assembly", "impact": "Informational", "confidence": "High" diff --git a/tests/expected_json/inline_assembly_library.assembly.json b/tests/expected_json/inline_assembly_library.assembly.json index d3e3642b8..72e621970 100644 --- a/tests/expected_json/inline_assembly_library.assembly.json +++ b/tests/expected_json/inline_assembly_library.assembly.json @@ -207,6 +207,7 @@ ], "description": "VectorSum.sumAsm(uint256[]) (tests/inline_assembly_library.sol#16-22) uses assembly\n\t- INLINE ASM None (tests/inline_assembly_library.sol#18-21)\n", "markdown": "[VectorSum.sumAsm(uint256[])](tests/inline_assembly_library.sol#L16-L22) uses assembly\n\t- [INLINE ASM None](tests/inline_assembly_library.sol#L18-L21)\n", + "id": "3ff39c86f26b81703ac5df9ce9d176a0a2c9948abccc76da3768272588588c04", "check": "assembly", "impact": "Informational", "confidence": "High" @@ -465,6 +466,7 @@ ], "description": "VectorSum.sumPureAsm(uint256[]) (tests/inline_assembly_library.sol#25-47) uses assembly\n\t- INLINE ASM None (tests/inline_assembly_library.sol#26-47)\n", "markdown": "[VectorSum.sumPureAsm(uint256[])](tests/inline_assembly_library.sol#L25-L47) uses assembly\n\t- [INLINE ASM None](tests/inline_assembly_library.sol#L26-L47)\n", + "id": "423795860d3892652fcf5005055c4781586100070e0ecdffb7ca1014c3958191", "check": "assembly", "impact": "Informational", "confidence": "High" diff --git a/tests/expected_json/locked_ether-0.5.1.locked-ether.json b/tests/expected_json/locked_ether-0.5.1.locked-ether.json index 3d7238e5b..f8ef8749d 100644 --- a/tests/expected_json/locked_ether-0.5.1.locked-ether.json +++ b/tests/expected_json/locked_ether-0.5.1.locked-ether.json @@ -73,6 +73,7 @@ ], "description": "Contract locking ether found in :\n\tContract OnlyLocked (tests/locked_ether-0.5.1.sol#26) has payable functions:\n\t - Locked.receive() (tests/locked_ether-0.5.1.sol#4-6)\n\tBut does not have a function to withdraw the ether\n", "markdown": "Contract locking ether found in :\n\tContract [OnlyLocked](tests/locked_ether-0.5.1.sol#L26) has payable functions:\n\t - [Locked.receive()](tests/locked_ether-0.5.1.sol#L4-L6)\n\tBut does not have a function to withdraw the ether\n", + "id": "38b2d47301e59ffa598ec48a8e874e6a7070d6cf4e4ab2909f33a8b72fc28a4b", "check": "locked-ether", "impact": "Medium", "confidence": "High" diff --git a/tests/expected_json/locked_ether.locked-ether.json b/tests/expected_json/locked_ether.locked-ether.json index 765e4103e..07f410f9d 100644 --- a/tests/expected_json/locked_ether.locked-ether.json +++ b/tests/expected_json/locked_ether.locked-ether.json @@ -73,6 +73,7 @@ ], "description": "Contract locking ether found in :\n\tContract OnlyLocked (tests/locked_ether.sol#26) has payable functions:\n\t - Locked.receive() (tests/locked_ether.sol#4-6)\n\tBut does not have a function to withdraw the ether\n", "markdown": "Contract locking ether found in :\n\tContract [OnlyLocked](tests/locked_ether.sol#L26) has payable functions:\n\t - [Locked.receive()](tests/locked_ether.sol#L4-L6)\n\tBut does not have a function to withdraw the ether\n", + "id": "38b2d47301e59ffa598ec48a8e874e6a7070d6cf4e4ab2909f33a8b72fc28a4b", "check": "locked-ether", "impact": "Medium", "confidence": "High" diff --git a/tests/expected_json/low_level_calls.low-level-calls.json b/tests/expected_json/low_level_calls.low-level-calls.json index f3dd0cf61..90a8fea54 100644 --- a/tests/expected_json/low_level_calls.low-level-calls.json +++ b/tests/expected_json/low_level_calls.low-level-calls.json @@ -118,6 +118,7 @@ ], "description": "Low level call in Sender.send(address) (tests/low_level_calls.sol#5-7):\n\t- _receiver.call.value(msg.value).gas(7777)() (tests/low_level_calls.sol#6)\n", "markdown": "Low level call in [Sender.send(address)](tests/low_level_calls.sol#L5-L7):\n\t- [_receiver.call.value(msg.value).gas(7777)()](tests/low_level_calls.sol#L6)\n", + "id": "5cb382cdae5ceb68ac0c67a88d9233a949dc990d5899578415da8139804cf149", "check": "low-level-calls", "impact": "Informational", "confidence": "High" diff --git a/tests/expected_json/multiple_calls_in_loop.calls-loop.json b/tests/expected_json/multiple_calls_in_loop.calls-loop.json index f54be581b..b2779d505 100644 --- a/tests/expected_json/multiple_calls_in_loop.calls-loop.json +++ b/tests/expected_json/multiple_calls_in_loop.calls-loop.json @@ -142,6 +142,7 @@ ], "description": "CallInLoop.bad() (tests/multiple_calls_in_loop.sol#9-13) has external calls inside a loop: destinations[i].transfer(i) (tests/multiple_calls_in_loop.sol#11)\n", "markdown": "[CallInLoop.bad()](tests/multiple_calls_in_loop.sol#L9-L13) has external calls inside a loop: [destinations[i].transfer(i)](tests/multiple_calls_in_loop.sol#L11)\n", + "id": "70793ed549e12ccf0735e919c865f639eec14665073037a97794396066e650ed", "check": "calls-loop", "impact": "Low", "confidence": "Medium" diff --git a/tests/expected_json/naming_convention.naming-convention.json b/tests/expected_json/naming_convention.naming-convention.json index b71a64845..9e9d4d317 100644 --- a/tests/expected_json/naming_convention.naming-convention.json +++ b/tests/expected_json/naming_convention.naming-convention.json @@ -75,6 +75,7 @@ ], "description": "Contract naming (tests/naming_convention.sol#3-48) is not in CapWords\n", "markdown": "Contract [naming](tests/naming_convention.sol#L3-L48) is not in CapWords\n", + "id": "7247d550fb327e3aeb21c82714137e5b45a7e9eeaa6a1bc878102c8081033f85", "check": "naming-convention", "impact": "Informational", "confidence": "High" @@ -173,6 +174,7 @@ ], "description": "Struct naming.test (tests/naming_convention.sol#14-16) is not in CapWords\n", "markdown": "Struct [naming.test](tests/naming_convention.sol#L14-L16) is not in CapWords\n", + "id": "0ef3ea412cb30b1f0df5fa2af4a7a06e2bf0373fae0770fd9e301aed12c209cf", "check": "naming-convention", "impact": "Informational", "confidence": "High" @@ -270,6 +272,7 @@ ], "description": "Event namingevent_(uint256) (tests/naming_convention.sol#23) is not in CapWords\n", "markdown": "Event [namingevent_(uint256)](tests/naming_convention.sol#L23) is not in CapWords\n", + "id": "978ecf4a2c8b96d947e60f6601cf60d0e25e07ebe80ebbc37a7e7f279afd1405", "check": "naming-convention", "impact": "Informational", "confidence": "High" @@ -370,6 +373,7 @@ ], "description": "Function naming.GetOne() (tests/naming_convention.sol#30-33) is not in mixedCase\n", "markdown": "Function [naming.GetOne()](tests/naming_convention.sol#L30-L33) is not in mixedCase\n", + "id": "bf6f97d6a82b84284efdade52d01bd6112007426e2e88d1568190d63c5c4a049", "check": "naming-convention", "impact": "Informational", "confidence": "High" @@ -490,6 +494,7 @@ ], "description": "Parameter naming.setInt(uint256,uint256).Number2 (tests/naming_convention.sol#35) is not in mixedCase\n", "markdown": "Parameter [naming.setInt(uint256,uint256).Number2](tests/naming_convention.sol#L35) is not in mixedCase\n", + "id": "f03bff0b488524254e19ff7d688d34211cd2f29934e22417c9f1fa43fc4a08ad", "check": "naming-convention", "impact": "Informational", "confidence": "High" @@ -586,6 +591,7 @@ ], "description": "Constant naming.MY_other_CONSTANT (tests/naming_convention.sol#9) is not in UPPER_CASE_WITH_UNDERSCORES\n", "markdown": "Constant [naming.MY_other_CONSTANT](tests/naming_convention.sol#L9) is not in UPPER_CASE_WITH_UNDERSCORES\n", + "id": "596c2e8064f8f2df55cd5c878eb59c0a74ac7f20719c420d8af307f2431a1a90", "check": "naming-convention", "impact": "Informational", "confidence": "High" @@ -682,6 +688,7 @@ ], "description": "Variable naming.Var_One (tests/naming_convention.sol#11) is not in mixedCase\n", "markdown": "Variable [naming.Var_One](tests/naming_convention.sol#L11) is not in mixedCase\n", + "id": "34b7c817201b3f3086fc3541f140898d9e9aabe999b1c0a6ef8639ec04351f26", "check": "naming-convention", "impact": "Informational", "confidence": "High" @@ -778,6 +785,7 @@ ], "description": "Enum naming.numbers (tests/naming_convention.sol#6) is not in CapWords\n", "markdown": "Enum [naming.numbers](tests/naming_convention.sol#L6) is not in CapWords\n", + "id": "7c87b076ea2865060182cf11d155caadb1dcea415ccce0ca8563a74a01611fc2", "check": "naming-convention", "impact": "Informational", "confidence": "High" @@ -877,6 +885,7 @@ ], "description": "Modifier naming.CantDo() (tests/naming_convention.sol#41-43) is not in mixedCase\n", "markdown": "Modifier [naming.CantDo()](tests/naming_convention.sol#L41-L43) is not in mixedCase\n", + "id": "b8a754a01bd47127f00032cdedd0ade3e27e6543631d8f5bc9e44365ab732895", "check": "naming-convention", "impact": "Informational", "confidence": "High" @@ -964,6 +973,7 @@ ], "description": "Parameter T.test(uint256,uint256)._used (tests/naming_convention.sol#59) is not in mixedCase\n", "markdown": "Parameter [T.test(uint256,uint256)._used](tests/naming_convention.sol#L59) is not in mixedCase\n", + "id": "818962ad9f50f13eb87b5c7deade22666431945fb60055f572b38246cfbf311e", "check": "naming-convention", "impact": "Informational", "confidence": "High" @@ -1029,6 +1039,7 @@ ], "description": "Variable T._myPublicVar (tests/naming_convention.sol#56) is not in mixedCase\n", "markdown": "Variable [T._myPublicVar](tests/naming_convention.sol#L56) is not in mixedCase\n", + "id": "8acd53815786acad5b92b51366daf79182a67ab438daa41a6e1ec8a9601fa9a3", "check": "naming-convention", "impact": "Informational", "confidence": "High" @@ -1094,6 +1105,7 @@ ], "description": "Variable T.l (tests/naming_convention.sol#67) used l, O, I, which should not be used\n", "markdown": "Variable [T.l](tests/naming_convention.sol#L67) used l, O, I, which should not be used\n", + "id": "b595f9e6d03b8b501b7c4a9bf8ff0ad9bf11448a25f53d63ab5031c95f8ae89c", "check": "naming-convention", "impact": "Informational", "confidence": "High" diff --git a/tests/expected_json/old_solc.sol.json.solc-version.json b/tests/expected_json/old_solc.sol.json.solc-version.json index 716b2e410..6a466b562 100644 --- a/tests/expected_json/old_solc.sol.json.solc-version.json +++ b/tests/expected_json/old_solc.sol.json.solc-version.json @@ -31,6 +31,7 @@ ], "description": "Pragma version0.4.21 (None) allows old versions\n", "markdown": "Pragma version[0.4.21](None) allows old versions\n", + "id": "328ceb03806c74c48201abc80cb5625f6c8f47711913161dc99748ee6a99b64f", "check": "solc-version", "impact": "Informational", "confidence": "High" diff --git a/tests/expected_json/pragma.0.4.24.pragma.json b/tests/expected_json/pragma.0.4.24.pragma.json index 6a8687359..855d1a84e 100644 --- a/tests/expected_json/pragma.0.4.24.pragma.json +++ b/tests/expected_json/pragma.0.4.24.pragma.json @@ -60,6 +60,7 @@ ], "description": "Different versions of Solidity is used in :\n\t- Version used: ['^0.4.23', '^0.4.24']\n\t- ^0.4.23 (tests/pragma.0.4.23.sol#1)\n\t- ^0.4.24 (tests/pragma.0.4.24.sol#1)\n", "markdown": "Different versions of Solidity is used in :\n\t- Version used: ['^0.4.23', '^0.4.24']\n\t- [^0.4.23](tests/pragma.0.4.23.sol#L1)\n\t- [^0.4.24](tests/pragma.0.4.24.sol#L1)\n", + "id": "ab9edf8af725d611d1eaeb16713c0f2e9f51804dc985b1bc823bd87645713fb7", "check": "pragma", "impact": "Informational", "confidence": "High" diff --git a/tests/expected_json/reentrancy-0.5.1.reentrancy-eth.json b/tests/expected_json/reentrancy-0.5.1.reentrancy-eth.json index 7923f8ed2..59a7be011 100644 --- a/tests/expected_json/reentrancy-0.5.1.reentrancy-eth.json +++ b/tests/expected_json/reentrancy-0.5.1.reentrancy-eth.json @@ -349,6 +349,7 @@ ], "description": "Reentrancy in Reentrancy.withdrawBalance() (tests/reentrancy-0.5.1.sol#14-22):\n\tExternal calls:\n\t- (ret,mem) = msg.sender.call.value(userBalance[msg.sender])() (tests/reentrancy-0.5.1.sol#17)\n\tState variables written after the call(s):\n\t- Reentrancy.userBalance (tests/reentrancy-0.5.1.sol#4) in userBalance[msg.sender] = 0 (tests/reentrancy-0.5.1.sol#21)\n", "markdown": "Reentrancy in [Reentrancy.withdrawBalance()](tests/reentrancy-0.5.1.sol#L14-L22):\n\tExternal calls:\n\t- [(ret,mem) = msg.sender.call.value(userBalance[msg.sender])()](tests/reentrancy-0.5.1.sol#L17)\n\tState variables written after the call(s):\n\t- [Reentrancy.userBalance](tests/reentrancy-0.5.1.sol#L4) in [userBalance[msg.sender] = 0](tests/reentrancy-0.5.1.sol#L21)\n", + "id": "90119c12446a44e514bb4ccd7a0e869f210d7c3ec349d24d4237ace685a75df9", "check": "reentrancy-eth", "impact": "High", "confidence": "Medium" @@ -702,6 +703,7 @@ ], "description": "Reentrancy in Reentrancy.withdrawBalance_fixed_3() (tests/reentrancy-0.5.1.sol#44-53):\n\tExternal calls:\n\t- (ret,mem) = msg.sender.call.value(amount)() (tests/reentrancy-0.5.1.sol#49)\n\tState variables written after the call(s):\n\t- Reentrancy.userBalance (tests/reentrancy-0.5.1.sol#4) in userBalance[msg.sender] = amount (tests/reentrancy-0.5.1.sol#51)\n", "markdown": "Reentrancy in [Reentrancy.withdrawBalance_fixed_3()](tests/reentrancy-0.5.1.sol#L44-L53):\n\tExternal calls:\n\t- [(ret,mem) = msg.sender.call.value(amount)()](tests/reentrancy-0.5.1.sol#L49)\n\tState variables written after the call(s):\n\t- [Reentrancy.userBalance](tests/reentrancy-0.5.1.sol#L4) in [userBalance[msg.sender] = amount](tests/reentrancy-0.5.1.sol#L51)\n", + "id": "048dce6132290bdee94cd1e52c330873fed4b1c9ad2f49df4ba3d6ef49266a41", "check": "reentrancy-eth", "impact": "High", "confidence": "Medium" diff --git a/tests/expected_json/reentrancy.reentrancy-eth.json b/tests/expected_json/reentrancy.reentrancy-eth.json index 2f403e06e..2c0065199 100644 --- a/tests/expected_json/reentrancy.reentrancy-eth.json +++ b/tests/expected_json/reentrancy.reentrancy-eth.json @@ -400,6 +400,7 @@ ], "description": "Reentrancy in Reentrancy.withdrawBalance() (tests/reentrancy.sol#14-21):\n\tExternal calls:\n\t- ! (msg.sender.call.value(userBalance[msg.sender])()) (tests/reentrancy.sol#17)\n\tState variables written after the call(s):\n\t- Reentrancy.userBalance (tests/reentrancy.sol#4) in userBalance[msg.sender] = 0 (tests/reentrancy.sol#20)\n", "markdown": "Reentrancy in [Reentrancy.withdrawBalance()](tests/reentrancy.sol#L14-L21):\n\tExternal calls:\n\t- [! (msg.sender.call.value(userBalance[msg.sender])())](tests/reentrancy.sol#L17)\n\tState variables written after the call(s):\n\t- [Reentrancy.userBalance](tests/reentrancy.sol#L4) in [userBalance[msg.sender] = 0](tests/reentrancy.sol#L20)\n", + "id": "330f0fadcfdda2b4364ee67d3112ff00e0e369162004c451163f0663c9b01313", "check": "reentrancy-eth", "impact": "High", "confidence": "Medium" @@ -798,6 +799,7 @@ ], "description": "Reentrancy in Reentrancy.withdrawBalance_nested() (tests/reentrancy.sol#64-70):\n\tExternal calls:\n\t- msg.sender.call.value(amount / 2)() (tests/reentrancy.sol#67)\n\tState variables written after the call(s):\n\t- Reentrancy.userBalance (tests/reentrancy.sol#4) in userBalance[msg.sender] = 0 (tests/reentrancy.sol#68)\n", "markdown": "Reentrancy in [Reentrancy.withdrawBalance_nested()](tests/reentrancy.sol#L64-L70):\n\tExternal calls:\n\t- [msg.sender.call.value(amount / 2)()](tests/reentrancy.sol#L67)\n\tState variables written after the call(s):\n\t- [Reentrancy.userBalance](tests/reentrancy.sol#L4) in [userBalance[msg.sender] = 0](tests/reentrancy.sol#L68)\n", + "id": "30220828bfef61c2377527c7cee2ae5be443001f8dd39992d6e5af67153c402f", "check": "reentrancy-eth", "impact": "High", "confidence": "Medium" diff --git a/tests/expected_json/right_to_left_override.rtlo.json b/tests/expected_json/right_to_left_override.rtlo.json index e7540f466..201f4cdf7 100644 --- a/tests/expected_json/right_to_left_override.rtlo.json +++ b/tests/expected_json/right_to_left_override.rtlo.json @@ -26,6 +26,7 @@ ], "description": "/home/travis/build/crytic/slither/tests/right_to_left_override.sol contains a unicode right-to-left-override character at byte offset 96:\n\t- b' test1(/*A\\xe2\\x80\\xae/*B*/2 , 1/*\\xe2\\x80\\xad'\n", "markdown": "/home/travis/build/crytic/slither/tests/right_to_left_override.sol contains a unicode right-to-left-override character at byte offset 96:\n\t- b' test1(/*A\\xe2\\x80\\xae/*B*/2 , 1/*\\xe2\\x80\\xad'\n", + "id": "a6c8caf0e8d2182254c7b66c9808b999315b14fe10087f12bdc0afa72a43c223", "check": "rtlo", "impact": "High", "confidence": "High" diff --git a/tests/expected_json/shadowing_abstract.shadowing-abstract.json b/tests/expected_json/shadowing_abstract.shadowing-abstract.json index c83b58049..44da69923 100644 --- a/tests/expected_json/shadowing_abstract.shadowing-abstract.json +++ b/tests/expected_json/shadowing_abstract.shadowing-abstract.json @@ -90,6 +90,7 @@ ], "description": "DerivedContract.owner (tests/shadowing_abstract.sol#7) shadows:\n\t- BaseContract.owner (tests/shadowing_abstract.sol#2)\n", "markdown": "[DerivedContract.owner](tests/shadowing_abstract.sol#L7) shadows:\n\t- [BaseContract.owner](tests/shadowing_abstract.sol#L2)\n", + "id": "9c5c3fc5091b9ecd6ec271fdbb3036d9d3426cdf9a09d6cc293fd7de9240e4ab", "check": "shadowing-abstract", "impact": "Medium", "confidence": "High" diff --git a/tests/expected_json/shadowing_builtin_symbols.shadowing-builtin.json b/tests/expected_json/shadowing_builtin_symbols.shadowing-builtin.json index 771dac106..6f599cd31 100644 --- a/tests/expected_json/shadowing_builtin_symbols.shadowing-builtin.json +++ b/tests/expected_json/shadowing_builtin_symbols.shadowing-builtin.json @@ -51,6 +51,7 @@ ], "description": "BaseContract.blockhash (tests/shadowing_builtin_symbols.sol#4) (state variable) shadows built-in symbol\"\n", "markdown": "[BaseContract.blockhash](tests/shadowing_builtin_symbols.sol#L4) (state variable) shadows built-in symbol\"\n", + "id": "61d1c1452e694c321d00576decdf35c62efbe8860f664273955fadce5e063cc8", "check": "shadowing-builtin", "impact": "Low", "confidence": "High" @@ -103,6 +104,7 @@ ], "description": "BaseContract.now (tests/shadowing_builtin_symbols.sol#5) (state variable) shadows built-in symbol\"\n", "markdown": "[BaseContract.now](tests/shadowing_builtin_symbols.sol#L5) (state variable) shadows built-in symbol\"\n", + "id": "942ad0405af0bc533374dded6e2474c53892747c98d2df14d59cbb6840fa18b3", "check": "shadowing-builtin", "impact": "Low", "confidence": "High" @@ -156,6 +158,7 @@ ], "description": "BaseContractrevert(bool) (tests/shadowing_builtin_symbols.sol#7) (event) shadows built-in symbol\"\n", "markdown": "[BaseContractrevert(bool)](tests/shadowing_builtin_symbols.sol#L7) (event) shadows built-in symbol\"\n", + "id": "9c428e61cb4832d899b2bb711c8d428154425dbadf5dfc2e2d857254824d8f72", "check": "shadowing-builtin", "impact": "Low", "confidence": "High" @@ -212,6 +215,7 @@ ], "description": "ExtendedContract.assert(bool) (tests/shadowing_builtin_symbols.sol#13-15) (function) shadows built-in symbol\"\n", "markdown": "[ExtendedContract.assert(bool)](tests/shadowing_builtin_symbols.sol#L13-L15) (function) shadows built-in symbol\"\n", + "id": "b3a1b23c1daed52b1a2ff5fb76d4fcdf2bc0b2126524303321cf8e7835116d6f", "check": "shadowing-builtin", "impact": "Low", "confidence": "High" @@ -288,6 +292,7 @@ ], "description": "ExtendedContract.assert(bool).msg (tests/shadowing_builtin_symbols.sol#14) (local variable) shadows built-in symbol\"\n", "markdown": "[ExtendedContract.assert(bool).msg](tests/shadowing_builtin_symbols.sol#L14) (local variable) shadows built-in symbol\"\n", + "id": "a2a7e1e27320d38e52b51c9b1ec67cca0a403673ff6fdd59652f9cd8425d011f", "check": "shadowing-builtin", "impact": "Low", "confidence": "High" @@ -341,6 +346,7 @@ ], "description": "ExtendedContract.ecrecover (tests/shadowing_builtin_symbols.sol#11) (state variable) shadows built-in symbol\"\n", "markdown": "[ExtendedContract.ecrecover](tests/shadowing_builtin_symbols.sol#L11) (state variable) shadows built-in symbol\"\n", + "id": "39737925cf3bd4ebf9a1c7bbe39da8b80ba28e5a3d93a938d1a4cca78a6a436d", "check": "shadowing-builtin", "impact": "Low", "confidence": "High" @@ -405,6 +411,7 @@ ], "description": "FurtherExtendedContract.require() (tests/shadowing_builtin_symbols.sol#23-28) (modifier) shadows built-in symbol\"\n", "markdown": "[FurtherExtendedContract.require()](tests/shadowing_builtin_symbols.sol#L23-L28) (modifier) shadows built-in symbol\"\n", + "id": "db6c26c9a7c319c1a34c486e6e625c0906a2b118f8cd72f38a38c167832aab4f", "check": "shadowing-builtin", "impact": "Low", "confidence": "High" @@ -489,6 +496,7 @@ ], "description": "FurtherExtendedContract.require().keccak256 (tests/shadowing_builtin_symbols.sol#25) (local variable) shadows built-in symbol\"\n", "markdown": "[FurtherExtendedContract.require().keccak256](tests/shadowing_builtin_symbols.sol#L25) (local variable) shadows built-in symbol\"\n", + "id": "40f0453d27abf2d9ed76fe60853b6e2e0cd9a443d639e9da457460ea02b2bdc7", "check": "shadowing-builtin", "impact": "Low", "confidence": "High" @@ -573,6 +581,7 @@ ], "description": "FurtherExtendedContract.require().sha3 (tests/shadowing_builtin_symbols.sol#26) (local variable) shadows built-in symbol\"\n", "markdown": "[FurtherExtendedContract.require().sha3](tests/shadowing_builtin_symbols.sol#L26) (local variable) shadows built-in symbol\"\n", + "id": "c481dbbf77c99cb337740a656ebabae1c89bf13b9d7b7d315dcf54feeab1cd63", "check": "shadowing-builtin", "impact": "Low", "confidence": "High" @@ -631,6 +640,7 @@ ], "description": "FurtherExtendedContract.blockhash (tests/shadowing_builtin_symbols.sol#19) (state variable) shadows built-in symbol\"\n", "markdown": "[FurtherExtendedContract.blockhash](tests/shadowing_builtin_symbols.sol#L19) (state variable) shadows built-in symbol\"\n", + "id": "d405ccbec679f921252d475591a890a89a023b375dc4994119967693692f8da9", "check": "shadowing-builtin", "impact": "Low", "confidence": "High" @@ -689,6 +699,7 @@ ], "description": "FurtherExtendedContract.this (tests/shadowing_builtin_symbols.sol#20) (state variable) shadows built-in symbol\"\n", "markdown": "[FurtherExtendedContract.this](tests/shadowing_builtin_symbols.sol#L20) (state variable) shadows built-in symbol\"\n", + "id": "87e1cc0cb95181dd120d3e6e55d89fdc7b5cd01da2f89cd7a3d105738f57c10b", "check": "shadowing-builtin", "impact": "Low", "confidence": "High" @@ -747,6 +758,7 @@ ], "description": "FurtherExtendedContract.abi (tests/shadowing_builtin_symbols.sol#21) (state variable) shadows built-in symbol\"\n", "markdown": "[FurtherExtendedContract.abi](tests/shadowing_builtin_symbols.sol#L21) (state variable) shadows built-in symbol\"\n", + "id": "4665243a2df090e3543ab26447528fa3401916f4669fe1264145891846d4bc40", "check": "shadowing-builtin", "impact": "Low", "confidence": "High" @@ -797,6 +809,7 @@ ], "description": "Reserved.mutable (tests/shadowing_builtin_symbols.sol#32) (state variable) shadows built-in symbol\"\n", "markdown": "[Reserved.mutable](tests/shadowing_builtin_symbols.sol#L32) (state variable) shadows built-in symbol\"\n", + "id": "11840553a9e11623596d7a07275814e65a5b1d90277ae0e2954cd8ce74d6a6d2", "check": "shadowing-builtin", "impact": "Low", "confidence": "High" diff --git a/tests/expected_json/shadowing_local_variable.shadowing-local.json b/tests/expected_json/shadowing_local_variable.shadowing-local.json index 407cdbfb5..859d5326b 100644 --- a/tests/expected_json/shadowing_local_variable.shadowing-local.json +++ b/tests/expected_json/shadowing_local_variable.shadowing-local.json @@ -210,6 +210,7 @@ ], "description": "FurtherExtendedContract.shadowingParent(uint256).x (tests/shadowing_local_variable.sol#25) shadows:\n\t- FurtherExtendedContract.x (tests/shadowing_local_variable.sol#17) (state variable)\n\t- ExtendedContract.x (tests/shadowing_local_variable.sol#9) (state variable)\n\t- BaseContract.x (tests/shadowing_local_variable.sol#4) (state variable)\n", "markdown": "[FurtherExtendedContract.shadowingParent(uint256).x](tests/shadowing_local_variable.sol#L25) shadows:\n\t- [FurtherExtendedContract.x](tests/shadowing_local_variable.sol#L17) (state variable)\n\t- [ExtendedContract.x](tests/shadowing_local_variable.sol#L9) (state variable)\n\t- [BaseContract.x](tests/shadowing_local_variable.sol#L4) (state variable)\n", + "id": "0991435c12aa2d6f15e8da2a00a18e9c58ef65dcf31137cdb561655317353247", "check": "shadowing-local", "impact": "Low", "confidence": "High" @@ -329,6 +330,7 @@ ], "description": "FurtherExtendedContract.shadowingParent(uint256).y (tests/shadowing_local_variable.sol#25) shadows:\n\t- BaseContract.y (tests/shadowing_local_variable.sol#5) (state variable)\n", "markdown": "[FurtherExtendedContract.shadowingParent(uint256).y](tests/shadowing_local_variable.sol#L25) shadows:\n\t- [BaseContract.y](tests/shadowing_local_variable.sol#L5) (state variable)\n", + "id": "465bd81cbb09a3d2cc84ea6102fb059296f1970e85e2d86a171f8219f1a34508", "check": "shadowing-local", "impact": "Low", "confidence": "High" @@ -452,6 +454,7 @@ ], "description": "FurtherExtendedContract.shadowingParent(uint256).z (tests/shadowing_local_variable.sol#25) shadows:\n\t- ExtendedContract.z() (tests/shadowing_local_variable.sol#11) (function)\n", "markdown": "[FurtherExtendedContract.shadowingParent(uint256).z](tests/shadowing_local_variable.sol#L25) shadows:\n\t- [ExtendedContract.z()](tests/shadowing_local_variable.sol#L11) (function)\n", + "id": "e3d2948e9c1252fe84e0d7e58f6682af7af84ef209f6e71f039faccabf07b0bd", "check": "shadowing-local", "impact": "Low", "confidence": "High" @@ -582,6 +585,7 @@ ], "description": "FurtherExtendedContract.shadowingParent(uint256).w (tests/shadowing_local_variable.sol#25) shadows:\n\t- FurtherExtendedContract.w() (tests/shadowing_local_variable.sol#20-23) (modifier)\n", "markdown": "[FurtherExtendedContract.shadowingParent(uint256).w](tests/shadowing_local_variable.sol#L25) shadows:\n\t- [FurtherExtendedContract.w()](tests/shadowing_local_variable.sol#L20-L23) (modifier)\n", + "id": "a94a2b9331482c75582868e6d3cc5c9b01487e7505f219abcf36a20d76e0b089", "check": "shadowing-local", "impact": "Low", "confidence": "High" @@ -705,6 +709,7 @@ ], "description": "FurtherExtendedContract.shadowingParent(uint256).v (tests/shadowing_local_variable.sol#25) shadows:\n\t- ExtendedContractv() (tests/shadowing_local_variable.sol#13) (event)\n", "markdown": "[FurtherExtendedContract.shadowingParent(uint256).v](tests/shadowing_local_variable.sol#L25) shadows:\n\t- [ExtendedContractv()](tests/shadowing_local_variable.sol#L13) (event)\n", + "id": "973e31cc30dc7a3e1f089dfa5848234075f237f78fa492c772b1083e12c79054", "check": "shadowing-local", "impact": "Low", "confidence": "High" diff --git a/tests/expected_json/shadowing_state_variable.shadowing-state.json b/tests/expected_json/shadowing_state_variable.shadowing-state.json index 2fa620ae0..bea1419f7 100644 --- a/tests/expected_json/shadowing_state_variable.shadowing-state.json +++ b/tests/expected_json/shadowing_state_variable.shadowing-state.json @@ -102,6 +102,7 @@ ], "description": "DerivedContract.owner (tests/shadowing_state_variable.sol#12) shadows:\n\t- BaseContract.owner (tests/shadowing_state_variable.sol#2)\n", "markdown": "[DerivedContract.owner](tests/shadowing_state_variable.sol#L12) shadows:\n\t- [BaseContract.owner](tests/shadowing_state_variable.sol#L2)\n", + "id": "9c5c3fc5091b9ecd6ec271fdbb3036d9d3426cdf9a09d6cc293fd7de9240e4ab", "check": "shadowing-state", "impact": "High", "confidence": "High" diff --git a/tests/expected_json/solc_version_incorrect.solc-version.json b/tests/expected_json/solc_version_incorrect.solc-version.json index af9d454de..121466f3e 100644 --- a/tests/expected_json/solc_version_incorrect.solc-version.json +++ b/tests/expected_json/solc_version_incorrect.solc-version.json @@ -34,6 +34,7 @@ ], "description": "Pragma version^0.4.23 (tests/solc_version_incorrect.sol#2) allows old versions\n", "markdown": "Pragma version[^0.4.23](tests/solc_version_incorrect.sol#L2) allows old versions\n", + "id": "c88d5b50c78f468b95732feb91693016824f78333adab2fdcca3152eec2bfa73", "check": "solc-version", "impact": "Informational", "confidence": "High" @@ -72,6 +73,7 @@ ], "description": "Pragma version>=0.4.0<0.6.0 (tests/solc_version_incorrect.sol#3) allows old versions\n", "markdown": "Pragma version[>=0.4.0<0.6.0](tests/solc_version_incorrect.sol#L3) allows old versions\n", + "id": "dfd3e70c2367b0c8eca5afa86d1773b9c7aa1d0a155e3a0495188800c41fe390", "check": "solc-version", "impact": "Informational", "confidence": "High" diff --git a/tests/expected_json/solc_version_incorrect_05.ast.json.solc-version.json b/tests/expected_json/solc_version_incorrect_05.ast.json.solc-version.json index a199ac228..d04fb3bbb 100644 --- a/tests/expected_json/solc_version_incorrect_05.ast.json.solc-version.json +++ b/tests/expected_json/solc_version_incorrect_05.ast.json.solc-version.json @@ -32,6 +32,7 @@ ], "description": "Pragma version^0.5.5 (None) is known to contain severe issue (https://solidity.readthedocs.io/en/v0.5.8/bugs.html)\n", "markdown": "Pragma version[^0.5.5](None) is known to contain severe issue (https://solidity.readthedocs.io/en/v0.5.8/bugs.html)\n", + "id": "8bcf06a2e2c13723dbc16f843f73830ebdb86b7e8ee599524a0b9824bb89381c", "check": "solc-version", "impact": "Informational", "confidence": "High" @@ -64,6 +65,7 @@ ], "description": "Pragma version0.5.7 (None) necessitates versions too recent to be trusted. Consider deploying with 0.5.3\n", "markdown": "Pragma version[0.5.7](None) necessitates versions too recent to be trusted. Consider deploying with 0.5.3\n", + "id": "997cf0cfc722f31f7566c3fd180c01b0c7466a19df7c65ee590e9f3778cf62ee", "check": "solc-version", "impact": "Informational", "confidence": "High" diff --git a/tests/expected_json/timestamp.timestamp.json b/tests/expected_json/timestamp.timestamp.json index 1819fe638..798c87186 100644 --- a/tests/expected_json/timestamp.timestamp.json +++ b/tests/expected_json/timestamp.timestamp.json @@ -148,6 +148,7 @@ ], "description": "Timestamp.bad0() (tests/timestamp.sol#4-6) uses timestamp for comparisons\n\tDangerous comparisons:\n\t- require(bool)(block.timestamp == 0) (tests/timestamp.sol#5)\n", "markdown": "[Timestamp.bad0()](tests/timestamp.sol#L4-L6) uses timestamp for comparisons\n\tDangerous comparisons:\n\t- [require(bool)(block.timestamp == 0)](tests/timestamp.sol#L5)\n", + "id": "40a3d28a47f4ff093afc58a30950747eef4db7fe47ace94e10bc4e763e77d82f", "check": "timestamp", "impact": "Low", "confidence": "Medium" @@ -299,6 +300,7 @@ ], "description": "Timestamp.bad1() (tests/timestamp.sol#8-11) uses timestamp for comparisons\n\tDangerous comparisons:\n\t- require(bool)(time == 0) (tests/timestamp.sol#10)\n", "markdown": "[Timestamp.bad1()](tests/timestamp.sol#L8-L11) uses timestamp for comparisons\n\tDangerous comparisons:\n\t- [require(bool)(time == 0)](tests/timestamp.sol#L10)\n", + "id": "62968bb5164984fc4ed41aa04d9413d371e20127d858b730fe122bc03c8e5c21", "check": "timestamp", "impact": "Low", "confidence": "Medium" @@ -448,6 +450,7 @@ ], "description": "Timestamp.bad2() (tests/timestamp.sol#13-15) uses timestamp for comparisons\n\tDangerous comparisons:\n\t- block.timestamp > 0 (tests/timestamp.sol#14)\n", "markdown": "[Timestamp.bad2()](tests/timestamp.sol#L13-L15) uses timestamp for comparisons\n\tDangerous comparisons:\n\t- [block.timestamp > 0](tests/timestamp.sol#L14)\n", + "id": "64a9f860d4e2c9cf89239b055236c4d39129725ffc45e3348bbd1856822b331d", "check": "timestamp", "impact": "Low", "confidence": "Medium" diff --git a/tests/expected_json/too_many_digits.too-many-digits.json b/tests/expected_json/too_many_digits.too-many-digits.json index 9e7a211f5..a847ee5ed 100644 --- a/tests/expected_json/too_many_digits.too-many-digits.json +++ b/tests/expected_json/too_many_digits.too-many-digits.json @@ -192,6 +192,7 @@ ], "description": "C.f() (tests/too_many_digits.sol#9-15) uses literals with too many digits:\n\t- x1 = 0x000001 (tests/too_many_digits.sol#10)\n", "markdown": "[C.f()](tests/too_many_digits.sol#L9-L15) uses literals with too many digits:\n\t- [x1 = 0x000001](tests/too_many_digits.sol#L10)\n", + "id": "ad33e4cde46622380bf364b6f0829b9a7c8491e1c219e977211e3ed81a9927ed", "check": "too-many-digits", "impact": "Informational", "confidence": "Medium" @@ -385,6 +386,7 @@ ], "description": "C.f() (tests/too_many_digits.sol#9-15) uses literals with too many digits:\n\t- x2 = 0x0000000000001 (tests/too_many_digits.sol#11)\n", "markdown": "[C.f()](tests/too_many_digits.sol#L9-L15) uses literals with too many digits:\n\t- [x2 = 0x0000000000001](tests/too_many_digits.sol#L11)\n", + "id": "584a7ffb54e80195135c9bdc36073c0f8edd8fb9f3208b3b2b181a5612f66c25", "check": "too-many-digits", "impact": "Informational", "confidence": "Medium" @@ -578,6 +580,7 @@ ], "description": "C.f() (tests/too_many_digits.sol#9-15) uses literals with too many digits:\n\t- x3 = 1000000000000000000 (tests/too_many_digits.sol#12)\n", "markdown": "[C.f()](tests/too_many_digits.sol#L9-L15) uses literals with too many digits:\n\t- [x3 = 1000000000000000000](tests/too_many_digits.sol#L12)\n", + "id": "b88a6bfe113e8a92f42e445b6c3dfeb799c2254bc3c9c17c8fd92cb48f342385", "check": "too-many-digits", "impact": "Informational", "confidence": "Medium" @@ -771,6 +774,7 @@ ], "description": "C.f() (tests/too_many_digits.sol#9-15) uses literals with too many digits:\n\t- x4 = 100000 (tests/too_many_digits.sol#13)\n", "markdown": "[C.f()](tests/too_many_digits.sol#L9-L15) uses literals with too many digits:\n\t- [x4 = 100000](tests/too_many_digits.sol#L13)\n", + "id": "3f65c504c516f8c6d309479729b47889c1b002be56d955a99eaafe9accab5688", "check": "too-many-digits", "impact": "Informational", "confidence": "Medium" @@ -960,6 +964,7 @@ ], "description": "C.h() (tests/too_many_digits.sol#20-24) uses literals with too many digits:\n\t- x2 = 100000 (tests/too_many_digits.sol#22)\n", "markdown": "[C.h()](tests/too_many_digits.sol#L20-L24) uses literals with too many digits:\n\t- [x2 = 100000](tests/too_many_digits.sol#L22)\n", + "id": "5f803e158c8bf519958ed6d12ba22e3100916c9a24f952d5cd574fd9ffe3aedb", "check": "too-many-digits", "impact": "Informational", "confidence": "Medium" diff --git a/tests/expected_json/tx_origin-0.5.1.tx-origin.json b/tests/expected_json/tx_origin-0.5.1.tx-origin.json index c0efe7dd0..fa5576ca0 100644 --- a/tests/expected_json/tx_origin-0.5.1.tx-origin.json +++ b/tests/expected_json/tx_origin-0.5.1.tx-origin.json @@ -156,6 +156,7 @@ ], "description": "TxOrigin.bug0() (tests/tx_origin-0.5.1.sol#9-11) uses tx.origin for authorization: require(bool)(tx.origin == owner) (tests/tx_origin-0.5.1.sol#10)\n", "markdown": "[TxOrigin.bug0()](tests/tx_origin-0.5.1.sol#L9-L11) uses tx.origin for authorization: [require(bool)(tx.origin == owner)](tests/tx_origin-0.5.1.sol#L10)\n", + "id": "a0c994da7e4fde05152f6b40d0db7741dc9154c0c27417d123775a43017fbd0c", "check": "tx-origin", "impact": "Medium", "confidence": "Medium" @@ -317,6 +318,7 @@ ], "description": "TxOrigin.bug2() (tests/tx_origin-0.5.1.sol#13-17) uses tx.origin for authorization: tx.origin != owner (tests/tx_origin-0.5.1.sol#14)\n", "markdown": "[TxOrigin.bug2()](tests/tx_origin-0.5.1.sol#L13-L17) uses tx.origin for authorization: [tx.origin != owner](tests/tx_origin-0.5.1.sol#L14)\n", + "id": "d7ce45ed56ab8579d6a9e88b9d57b5a3847a0925e3dd18dcb4a2f85b75bd7540", "check": "tx-origin", "impact": "Medium", "confidence": "Medium" diff --git a/tests/expected_json/tx_origin.tx-origin.json b/tests/expected_json/tx_origin.tx-origin.json index 23f4673f4..97cb3c5f2 100644 --- a/tests/expected_json/tx_origin.tx-origin.json +++ b/tests/expected_json/tx_origin.tx-origin.json @@ -156,6 +156,7 @@ ], "description": "TxOrigin.bug0() (tests/tx_origin.sol#9-11) uses tx.origin for authorization: require(bool)(tx.origin == owner) (tests/tx_origin.sol#10)\n", "markdown": "[TxOrigin.bug0()](tests/tx_origin.sol#L9-L11) uses tx.origin for authorization: [require(bool)(tx.origin == owner)](tests/tx_origin.sol#L10)\n", + "id": "ee75fdded0c273df2f7875bab74fc778ff8f0c85bbed968c80d5fd787bbef62e", "check": "tx-origin", "impact": "Medium", "confidence": "Medium" @@ -317,6 +318,7 @@ ], "description": "TxOrigin.bug2() (tests/tx_origin.sol#13-17) uses tx.origin for authorization: tx.origin != owner (tests/tx_origin.sol#14)\n", "markdown": "[TxOrigin.bug2()](tests/tx_origin.sol#L13-L17) uses tx.origin for authorization: [tx.origin != owner](tests/tx_origin.sol#L14)\n", + "id": "76446f7e20ba58a5f2094d357d8982c01225c8f61d73f33ed98316c3a4e892f0", "check": "tx-origin", "impact": "Medium", "confidence": "Medium" diff --git a/tests/expected_json/unchecked_lowlevel-0.5.1.unchecked-lowlevel.json b/tests/expected_json/unchecked_lowlevel-0.5.1.unchecked-lowlevel.json index 19197cda8..4b8604f09 100644 --- a/tests/expected_json/unchecked_lowlevel-0.5.1.unchecked-lowlevel.json +++ b/tests/expected_json/unchecked_lowlevel-0.5.1.unchecked-lowlevel.json @@ -130,6 +130,7 @@ ], "description": "MyConc.bad(address) (tests/unchecked_lowlevel-0.5.1.sol#2-4) ignores return value by dst.call.value(msg.value)() (tests/unchecked_lowlevel-0.5.1.sol#3)\n", "markdown": "[MyConc.bad(address)](tests/unchecked_lowlevel-0.5.1.sol#L2-L4) ignores return value by [dst.call.value(msg.value)()](tests/unchecked_lowlevel-0.5.1.sol#L3)\n", + "id": "44ab2ac22a418dc8ec66536dc7409a0a2c23fd3276b3fb7fe919ec1f1eaf483f", "check": "unchecked-lowlevel", "impact": "Medium", "confidence": "Medium" diff --git a/tests/expected_json/unchecked_lowlevel.unchecked-lowlevel.json b/tests/expected_json/unchecked_lowlevel.unchecked-lowlevel.json index 5c51078ad..77b157ea7 100644 --- a/tests/expected_json/unchecked_lowlevel.unchecked-lowlevel.json +++ b/tests/expected_json/unchecked_lowlevel.unchecked-lowlevel.json @@ -128,6 +128,7 @@ ], "description": "MyConc.bad(address) (tests/unchecked_lowlevel.sol#2-4) ignores return value by dst.call.value(msg.value)() (tests/unchecked_lowlevel.sol#3)\n", "markdown": "[MyConc.bad(address)](tests/unchecked_lowlevel.sol#L2-L4) ignores return value by [dst.call.value(msg.value)()](tests/unchecked_lowlevel.sol#L3)\n", + "id": "2975c4b0d2410cbe0a0901b36b4117c3c1017be5188e08339f0dd99a55b511ce", "check": "unchecked-lowlevel", "impact": "Medium", "confidence": "Medium" diff --git a/tests/expected_json/unchecked_send-0.5.1.unchecked-send.json b/tests/expected_json/unchecked_send-0.5.1.unchecked-send.json index 0ac4d1e2e..aef8a36f7 100644 --- a/tests/expected_json/unchecked_send-0.5.1.unchecked-send.json +++ b/tests/expected_json/unchecked_send-0.5.1.unchecked-send.json @@ -144,6 +144,7 @@ ], "description": "MyConc.bad(address) (tests/unchecked_send-0.5.1.sol#2-4) ignores return value by dst.send(msg.value) (tests/unchecked_send-0.5.1.sol#3)\n", "markdown": "[MyConc.bad(address)](tests/unchecked_send-0.5.1.sol#L2-L4) ignores return value by [dst.send(msg.value)](tests/unchecked_send-0.5.1.sol#L3)\n", + "id": "9e4d70a9e602a08c249500b8a32bd5cfe289229d2621a0f299c694c30c30d883", "check": "unchecked-send", "impact": "Medium", "confidence": "Medium" diff --git a/tests/expected_json/uninitialized-0.5.1.uninitialized-state.json b/tests/expected_json/uninitialized-0.5.1.uninitialized-state.json index 6b1497e20..9ee33fc72 100644 --- a/tests/expected_json/uninitialized-0.5.1.uninitialized-state.json +++ b/tests/expected_json/uninitialized-0.5.1.uninitialized-state.json @@ -103,6 +103,7 @@ ], "description": "Uninitialized.destination (tests/uninitialized-0.5.1.sol#5) is never initialized. It is used in:\n\t- Uninitialized.transfer() (tests/uninitialized-0.5.1.sol#7-9)\n", "markdown": "[Uninitialized.destination](tests/uninitialized-0.5.1.sol#L5) is never initialized. It is used in:\n\t- [Uninitialized.transfer()](tests/uninitialized-0.5.1.sol#L7-L9)\n", + "id": "e4711aebbd53922a9fe1e728917bf8e98eac065305e20d766b6b552debe79e44", "check": "uninitialized-state", "impact": "High", "confidence": "High" @@ -218,6 +219,7 @@ ], "description": "Test.balances (tests/uninitialized-0.5.1.sol#15) is never initialized. It is used in:\n\t- Test.use() (tests/uninitialized-0.5.1.sol#23-26)\n", "markdown": "[Test.balances](tests/uninitialized-0.5.1.sol#L15) is never initialized. It is used in:\n\t- [Test.use()](tests/uninitialized-0.5.1.sol#L23-L26)\n", + "id": "a2750d175b02d51aeb47a4576f74725ba991d3c8cf828a33ee78ccc34cf9e7d7", "check": "uninitialized-state", "impact": "High", "confidence": "High" @@ -339,6 +341,7 @@ ], "description": "Test2.st (tests/uninitialized-0.5.1.sol#45) is never initialized. It is used in:\n\t- Test2.use() (tests/uninitialized-0.5.1.sol#53-56)\n", "markdown": "[Test2.st](tests/uninitialized-0.5.1.sol#L45) is never initialized. It is used in:\n\t- [Test2.use()](tests/uninitialized-0.5.1.sol#L53-L56)\n", + "id": "427f100397f455d8000eff7b1d2463763ca8e452d5d98f7b7de693fd5e625a32", "check": "uninitialized-state", "impact": "High", "confidence": "High" @@ -459,6 +462,7 @@ ], "description": "Test2.v (tests/uninitialized-0.5.1.sol#47) is never initialized. It is used in:\n\t- Test2.init() (tests/uninitialized-0.5.1.sol#49-51)\n", "markdown": "[Test2.v](tests/uninitialized-0.5.1.sol#L47) is never initialized. It is used in:\n\t- [Test2.init()](tests/uninitialized-0.5.1.sol#L49-L51)\n", + "id": "bf96eee949943a12926cf1407a2df2b07e99b30a6fc2e78aebf088cdefcf77a7", "check": "uninitialized-state", "impact": "High", "confidence": "High" diff --git a/tests/expected_json/uninitialized.uninitialized-state.json b/tests/expected_json/uninitialized.uninitialized-state.json index 9e598c619..b53a6402b 100644 --- a/tests/expected_json/uninitialized.uninitialized-state.json +++ b/tests/expected_json/uninitialized.uninitialized-state.json @@ -103,6 +103,7 @@ ], "description": "Uninitialized.destination (tests/uninitialized.sol#5) is never initialized. It is used in:\n\t- Uninitialized.transfer() (tests/uninitialized.sol#7-9)\n", "markdown": "[Uninitialized.destination](tests/uninitialized.sol#L5) is never initialized. It is used in:\n\t- [Uninitialized.transfer()](tests/uninitialized.sol#L7-L9)\n", + "id": "e4711aebbd53922a9fe1e728917bf8e98eac065305e20d766b6b552debe79e44", "check": "uninitialized-state", "impact": "High", "confidence": "High" @@ -218,6 +219,7 @@ ], "description": "Test.balances (tests/uninitialized.sol#15) is never initialized. It is used in:\n\t- Test.use() (tests/uninitialized.sol#23-26)\n", "markdown": "[Test.balances](tests/uninitialized.sol#L15) is never initialized. It is used in:\n\t- [Test.use()](tests/uninitialized.sol#L23-L26)\n", + "id": "a2750d175b02d51aeb47a4576f74725ba991d3c8cf828a33ee78ccc34cf9e7d7", "check": "uninitialized-state", "impact": "High", "confidence": "High" @@ -339,6 +341,7 @@ ], "description": "Test2.st (tests/uninitialized.sol#45) is never initialized. It is used in:\n\t- Test2.use() (tests/uninitialized.sol#53-56)\n", "markdown": "[Test2.st](tests/uninitialized.sol#L45) is never initialized. It is used in:\n\t- [Test2.use()](tests/uninitialized.sol#L53-L56)\n", + "id": "427f100397f455d8000eff7b1d2463763ca8e452d5d98f7b7de693fd5e625a32", "check": "uninitialized-state", "impact": "High", "confidence": "High" @@ -459,6 +462,7 @@ ], "description": "Test2.v (tests/uninitialized.sol#47) is never initialized. It is used in:\n\t- Test2.init() (tests/uninitialized.sol#49-51)\n", "markdown": "[Test2.v](tests/uninitialized.sol#L47) is never initialized. It is used in:\n\t- [Test2.init()](tests/uninitialized.sol#L49-L51)\n", + "id": "bf96eee949943a12926cf1407a2df2b07e99b30a6fc2e78aebf088cdefcf77a7", "check": "uninitialized-state", "impact": "High", "confidence": "High" diff --git a/tests/expected_json/uninitialized_local_variable.uninitialized-local.json b/tests/expected_json/uninitialized_local_variable.uninitialized-local.json index b401a27f4..8e2b0d379 100644 --- a/tests/expected_json/uninitialized_local_variable.uninitialized-local.json +++ b/tests/expected_json/uninitialized_local_variable.uninitialized-local.json @@ -79,6 +79,7 @@ ], "description": "Uninitialized.func().uint_not_init (tests/uninitialized_local_variable.sol#4) is a local variable never initialiazed\n", "markdown": "[Uninitialized.func().uint_not_init](tests/uninitialized_local_variable.sol#L4) is a local variable never initialiazed\n", + "id": "8cb0b6b473ffecf3c2284584eb0012c742d36709f75c7516c3ba9748f3c27a98", "check": "uninitialized-local", "impact": "Medium", "confidence": "Medium" diff --git a/tests/expected_json/uninitialized_storage_pointer.uninitialized-storage.json b/tests/expected_json/uninitialized_storage_pointer.uninitialized-storage.json index 7c587e3bd..02c5143d2 100644 --- a/tests/expected_json/uninitialized_storage_pointer.uninitialized-storage.json +++ b/tests/expected_json/uninitialized_storage_pointer.uninitialized-storage.json @@ -85,6 +85,7 @@ ], "description": "Uninitialized.func().st_bug (tests/uninitialized_storage_pointer.sol#10) is a storage variable never initialiazed\n", "markdown": "[Uninitialized.func().st_bug](tests/uninitialized_storage_pointer.sol#L10) is a storage variable never initialiazed\n", + "id": "af9ceb591701024a2199a04e66a121086d330d4cdeb3b160514cce2bb440579f", "check": "uninitialized-storage", "impact": "High", "confidence": "High" diff --git a/tests/expected_json/unused_return.unused-return.json b/tests/expected_json/unused_return.unused-return.json index 1b84cb75f..c00154b8a 100644 --- a/tests/expected_json/unused_return.unused-return.json +++ b/tests/expected_json/unused_return.unused-return.json @@ -164,6 +164,7 @@ ], "description": "User.test(Target) (tests/unused_return.sol#17-29) ignores return value by t.f() (tests/unused_return.sol#18)\n", "markdown": "[User.test(Target)](tests/unused_return.sol#L17-L29) ignores return value by [t.f()](tests/unused_return.sol#L18)\n", + "id": "69f2810e24dbba754b406ce8b47e37543e9e491c0aa60d4dd2198c960e82b096", "check": "unused-return", "impact": "Medium", "confidence": "Medium" @@ -329,6 +330,7 @@ ], "description": "User.test(Target) (tests/unused_return.sol#17-29) ignores return value by a.add(0) (tests/unused_return.sol#22)\n", "markdown": "[User.test(Target)](tests/unused_return.sol#L17-L29) ignores return value by [a.add(0)](tests/unused_return.sol#L22)\n", + "id": "502f40d2e259e5e0268547489b716077dff7ce3df82fb05eb76ccb5ffa38f72b", "check": "unused-return", "impact": "Medium", "confidence": "Medium" diff --git a/tests/expected_json/unused_state.unused-state.json b/tests/expected_json/unused_state.unused-state.json index 58eec6bc6..786586e01 100644 --- a/tests/expected_json/unused_state.unused-state.json +++ b/tests/expected_json/unused_state.unused-state.json @@ -75,6 +75,7 @@ ], "description": "A.unused (tests/unused_state.sol#4) is never used in B (tests/unused_state.sol#11-16)\n", "markdown": "[A.unused](tests/unused_state.sol#L4) is never used in [B](tests/unused_state.sol#L11-L16)\n", + "id": "195279490862ae355bac3d27d0cdb1aa18200a5daed8f3dbd84dc5b120e29482", "check": "unused-state", "impact": "Informational", "confidence": "High" @@ -151,6 +152,7 @@ ], "description": "A.unused2 (tests/unused_state.sol#5) is never used in B (tests/unused_state.sol#11-16)\n", "markdown": "[A.unused2](tests/unused_state.sol#L5) is never used in [B](tests/unused_state.sol#L11-L16)\n", + "id": "886250d01813743573f3d311b742e0f818e0012ccbf8ad97738c029fd129d870", "check": "unused-state", "impact": "Informational", "confidence": "High" @@ -227,6 +229,7 @@ ], "description": "A.unused3 (tests/unused_state.sol#6) is never used in B (tests/unused_state.sol#11-16)\n", "markdown": "[A.unused3](tests/unused_state.sol#L6) is never used in [B](tests/unused_state.sol#L11-L16)\n", + "id": "e2ac51590509d97ff791ce50d9a711fc5ad01c20d23eacf6fb31939bd91b9f48", "check": "unused-state", "impact": "Informational", "confidence": "High" @@ -303,6 +306,7 @@ ], "description": "A.unused4 (tests/unused_state.sol#7) is never used in B (tests/unused_state.sol#11-16)\n", "markdown": "[A.unused4](tests/unused_state.sol#L7) is never used in [B](tests/unused_state.sol#L11-L16)\n", + "id": "562d3e6a04f6f6068c3e4f0c074ecdbcff87929e43ec6fbeb6c088e715f63cf2", "check": "unused-state", "impact": "Informational", "confidence": "High" diff --git a/tests/expected_json/void-cst.void-cst.json b/tests/expected_json/void-cst.void-cst.json index 1bb590390..6792be666 100644 --- a/tests/expected_json/void-cst.void-cst.json +++ b/tests/expected_json/void-cst.void-cst.json @@ -122,6 +122,7 @@ ], "description": "Void constructor called in D.constructor() (tests/void-cst.sol#10-12):\n\t- C() (tests/void-cst.sol#10)\n", "markdown": "Void constructor called in [D.constructor()](tests/void-cst.sol#L10-L12):\n\t- [C()](tests/void-cst.sol#L10)\n", + "id": "2d4e0ed4dc3c0871d43c6de59147f2bc48b0b2591237bfca8cdc3576388fce5a", "check": "void-cst", "impact": "Low", "confidence": "High" From 38077ce0779523177683b6786d225785ef8b8b56 Mon Sep 17 00:00:00 2001 From: Josselin Date: Tue, 12 Nov 2019 14:14:03 +0100 Subject: [PATCH 222/223] Filter known results using their ID --- slither/core/slither_core.py | 9 +++++++++ slither/utils/output.py | 2 +- 2 files changed, 10 insertions(+), 1 deletion(-) diff --git a/slither/core/slither_core.py b/slither/core/slither_core.py index 65fc23f6c..7a9f3f3d0 100644 --- a/slither/core/slither_core.py +++ b/slither/core/slither_core.py @@ -32,11 +32,13 @@ class Slither(Context): self._previous_results_filename = 'slither.db.json' self._results_to_hide = [] self._previous_results = [] + self._previous_results_ids = set() self._paths_to_filter = set() self._crytic_compile = None self._generate_patches = False + self._exclude_dependencies = False self._markdown_root = "" @@ -216,6 +218,9 @@ class Slither(Context): if r['elements'] and self._exclude_dependencies: return not all(element['source_mapping']['is_dependency'] for element in r['elements']) + if r['id'] in self._previous_results_ids: + return False + # Conserve previous result filtering. This is conserved for compatibility, but is meant to be removed return not r['description'] in [pr['description'] for pr in self._previous_results] def load_previous_results(self): @@ -224,6 +229,10 @@ class Slither(Context): if os.path.isfile(filename): with open(filename) as f: self._previous_results = json.load(f) + if self._previous_results: + for r in self._previous_results: + if 'id' in r: + self._previous_results_ids.add(r['id']) except json.decoder.JSONDecodeError: logger.error(red('Impossible to decode {}. Consider removing the file'.format(filename))) diff --git a/slither/utils/output.py b/slither/utils/output.py index d9fb77faf..01132c5a9 100644 --- a/slither/utils/output.py +++ b/slither/utils/output.py @@ -186,7 +186,7 @@ class Output: self._data['elements'] = [] self._data['description'] = ''.join(_convert_to_description(d) for d in info) self._data['markdown'] = ''.join(_convert_to_markdown(d, markdown_root) for d in info) - + id_txt = ''.join(_convert_to_id(d) for d in info) self._data['id'] = hashlib.sha3_256(id_txt.encode('utf-8')).hexdigest() From 7ae58b6964c7d657fc6f0d5d893f1eb4f48f044a Mon Sep 17 00:00:00 2001 From: Josselin Date: Tue, 12 Nov 2019 14:31:18 +0100 Subject: [PATCH 223/223] RTLO detector: show relative path to allow same ID on different machines --- scripts/tests_generate_expected_json_4.sh | 2 +- slither/detectors/source/rtlo.py | 4 +++- tests/expected_json/right_to_left_override.rtlo.json | 6 +++--- tests/expected_json/right_to_left_override.rtlo.txt | 2 +- 4 files changed, 8 insertions(+), 6 deletions(-) diff --git a/scripts/tests_generate_expected_json_4.sh b/scripts/tests_generate_expected_json_4.sh index 4e1def80c..790763ffe 100755 --- a/scripts/tests_generate_expected_json_4.sh +++ b/scripts/tests_generate_expected_json_4.sh @@ -54,5 +54,5 @@ generate_expected_json(){ #generate_expected_json tests/shadowing_builtin_symbols.sol "shadowing-builtin" #generate_expected_json tests/shadowing_local_variable.sol "shadowing-local" #generate_expected_json tests/solc_version_incorrect.sol "solc-version" -#generate_expected_json tests/right_to_left_override.sol "rtlo" +generate_expected_json tests/right_to_left_override.sol "rtlo" #generate_expected_json tests/unchecked_lowlevel.sol "unchecked-lowlevel" diff --git a/slither/detectors/source/rtlo.py b/slither/detectors/source/rtlo.py index d69201334..dbc976da2 100644 --- a/slither/detectors/source/rtlo.py +++ b/slither/detectors/source/rtlo.py @@ -68,7 +68,9 @@ contract Token else: # We found another instance of the character, define our output idx = start_index + result_index - info = f"{filename} contains a unicode right-to-left-override character at byte offset {idx}:\n" + + relative = self.slither.crytic_compile.filename_lookup(filename).relative + info = f"{relative} contains a unicode right-to-left-override character at byte offset {idx}:\n" # We have a patch, so pattern.find will return at least one result diff --git a/tests/expected_json/right_to_left_override.rtlo.json b/tests/expected_json/right_to_left_override.rtlo.json index 201f4cdf7..525e2c9ce 100644 --- a/tests/expected_json/right_to_left_override.rtlo.json +++ b/tests/expected_json/right_to_left_override.rtlo.json @@ -24,9 +24,9 @@ } } ], - "description": "/home/travis/build/crytic/slither/tests/right_to_left_override.sol contains a unicode right-to-left-override character at byte offset 96:\n\t- b' test1(/*A\\xe2\\x80\\xae/*B*/2 , 1/*\\xe2\\x80\\xad'\n", - "markdown": "/home/travis/build/crytic/slither/tests/right_to_left_override.sol contains a unicode right-to-left-override character at byte offset 96:\n\t- b' test1(/*A\\xe2\\x80\\xae/*B*/2 , 1/*\\xe2\\x80\\xad'\n", - "id": "a6c8caf0e8d2182254c7b66c9808b999315b14fe10087f12bdc0afa72a43c223", + "description": "tests/right_to_left_override.sol contains a unicode right-to-left-override character at byte offset 96:\n\t- b' test1(/*A\\xe2\\x80\\xae/*B*/2 , 1/*\\xe2\\x80\\xad'\n", + "markdown": "tests/right_to_left_override.sol contains a unicode right-to-left-override character at byte offset 96:\n\t- b' test1(/*A\\xe2\\x80\\xae/*B*/2 , 1/*\\xe2\\x80\\xad'\n", + "id": "7d1d0efc4c3c51bc1cc85572c67fa5244f01af85ab9e4bcef199d928a3b5447b", "check": "rtlo", "impact": "High", "confidence": "High" diff --git a/tests/expected_json/right_to_left_override.rtlo.txt b/tests/expected_json/right_to_left_override.rtlo.txt index 29326d789..96fd1dd4c 100644 --- a/tests/expected_json/right_to_left_override.rtlo.txt +++ b/tests/expected_json/right_to_left_override.rtlo.txt @@ -1,5 +1,5 @@  -/home/travis/build/crytic/slither/tests/right_to_left_override.sol contains a unicode right-to-left-override character at byte offset 96: +tests/right_to_left_override.sol contains a unicode right-to-left-override character at byte offset 96: - b' test1(/*A\xe2\x80\xae/*B*/2 , 1/*\xe2\x80\xad' Reference: https://github.com/crytic/slither/wiki/Detector-Documentation#right-to-left-override-character tests/right_to_left_override.sol analyzed (1 contracts with 1 detectors), 1 result(s) found