slither.core.slither_core

  1"""
  2    Main module
  3"""
  4import json
  5import logging
  6import os
  7import pathlib
  8import posixpath
  9import re
 10from collections import defaultdict
 11from typing import Optional, Dict, List, Set, Union, Tuple, TypeVar
 12
 13from crytic_compile import CryticCompile
 14from crytic_compile.utils.naming import Filename
 15
 16from slither.core.declarations.contract_level import ContractLevel
 17from slither.core.compilation_unit import SlitherCompilationUnit
 18from slither.core.context.context import Context
 19from slither.core.declarations import Contract, FunctionContract
 20from slither.core.declarations.top_level import TopLevel
 21from slither.core.source_mapping.source_mapping import SourceMapping, Source
 22from slither.slithir.variables import Constant
 23from slither.utils.colors import red
 24from slither.utils.sarif import read_triage_info
 25from slither.utils.source_mapping import get_definition, get_references, get_all_implementations
 26
 27logger = logging.getLogger("Slither")
 28logging.basicConfig()
 29
 30
 31def _relative_path_format(path: str) -> str:
 32    """
 33    Strip relative paths of "." and ".."
 34    """
 35    return path.split("..")[-1].strip(".").strip("/")
 36
 37
 38# pylint: disable=too-many-instance-attributes,too-many-public-methods
 39class SlitherCore(Context):
 40    """
 41    Slither static analyzer
 42    """
 43
 44    def __init__(self) -> None:
 45        super().__init__()
 46
 47        self._filename: Optional[str] = None
 48        self._raw_source_code: Dict[str, str] = {}
 49        self._source_code_to_line: Optional[Dict[str, List[str]]] = None
 50
 51        self._previous_results_filename: str = "slither.db.json"
 52
 53        # TODO: add cli flag to set these variables
 54        self.sarif_input: str = "export.sarif"
 55        self.sarif_triage: str = "export.sarif.sarifexplorer"
 56        self._results_to_hide: List = []
 57        self._previous_results: List = []
 58        # From triaged result
 59        self._previous_results_ids: Set[str] = set()
 60        # Every slither object has a list of result from detector
 61        # Because of the multiple compilation support, we might analyze
 62        # Multiple time the same result, so we remove duplicates
 63        self._currently_seen_resuts: Set[str] = set()
 64        self._paths_to_filter: Set[str] = set()
 65        self._paths_to_include: Set[str] = set()
 66
 67        self._crytic_compile: Optional[CryticCompile] = None
 68
 69        self._generate_patches = False
 70        self._exclude_dependencies = False
 71
 72        self._markdown_root = ""
 73
 74        # If set to true, slither will not catch errors during parsing
 75        self._disallow_partial: bool = False
 76        self._skip_assembly: bool = False
 77
 78        self._show_ignored_findings = False
 79
 80        # Maps from file to detector name to the start/end ranges for that detector.
 81        # Infinity is used to signal a detector has no end range.
 82        self._ignore_ranges: Dict[str, Dict[str, List[Tuple[int, ...]]]] = defaultdict(
 83            lambda: defaultdict(lambda: [(-1, -1)])
 84        )
 85
 86        self._compilation_units: List[SlitherCompilationUnit] = []
 87
 88        self._contracts: List[Contract] = []
 89        self._contracts_derived: List[Contract] = []
 90
 91        self._offset_to_min_offset: Optional[Dict[Filename, Dict[int, Set[int]]]] = None
 92        self._offset_to_objects: Optional[Dict[Filename, Dict[int, Set[SourceMapping]]]] = None
 93        self._offset_to_references: Optional[Dict[Filename, Dict[int, Set[Source]]]] = None
 94        self._offset_to_implementations: Optional[Dict[Filename, Dict[int, Set[Source]]]] = None
 95        self._offset_to_definitions: Optional[Dict[Filename, Dict[int, Set[Source]]]] = None
 96
 97        # Line prefix is used during the source mapping generation
 98        # By default we generate file.sol#1
 99        # But we allow to alter this (ex: file.sol:1) for vscode integration
100        self.line_prefix: str = "#"
101
102        # Use by the echidna printer
103        # If true, partial analysis is allowed
104        self.no_fail = False
105
106        self.skip_data_dependency = False
107
108    @property
109    def compilation_units(self) -> List[SlitherCompilationUnit]:
110        return list(self._compilation_units)
111
112    def add_compilation_unit(self, compilation_unit: SlitherCompilationUnit):
113        self._compilation_units.append(compilation_unit)
114
115    # endregion
116    ###################################################################################
117    ###################################################################################
118    # region Contracts
119    ###################################################################################
120    ###################################################################################
121
122    @property
123    def contracts(self) -> List[Contract]:
124        if not self._contracts:
125            all_contracts = [
126                compilation_unit.contracts for compilation_unit in self._compilation_units
127            ]
128            self._contracts = [item for sublist in all_contracts for item in sublist]
129        return self._contracts
130
131    @property
132    def contracts_derived(self) -> List[Contract]:
133        if not self._contracts_derived:
134            all_contracts = [
135                compilation_unit.contracts_derived for compilation_unit in self._compilation_units
136            ]
137            self._contracts_derived = [item for sublist in all_contracts for item in sublist]
138        return self._contracts_derived
139
140    def get_contract_from_name(self, contract_name: Union[str, Constant]) -> List[Contract]:
141        """
142            Return a contract from a name
143        Args:
144            contract_name (str): name of the contract
145        Returns:
146            Contract
147        """
148        contracts = []
149        for compilation_unit in self._compilation_units:
150            contracts += compilation_unit.get_contract_from_name(contract_name)
151        return contracts
152
153    ###################################################################################
154    ###################################################################################
155    # region Source code
156    ###################################################################################
157    ###################################################################################
158
159    @property
160    def source_code(self) -> Dict[str, str]:
161        """{filename: source_code (str)}: source code"""
162        return self._raw_source_code
163
164    @property
165    def filename(self) -> Optional[str]:
166        """str: Filename."""
167        return self._filename
168
169    @filename.setter
170    def filename(self, filename: str):
171        self._filename = filename
172
173    def add_source_code(self, path: str) -> None:
174        """
175        :param path:
176        :return:
177        """
178        if self.crytic_compile and path in self.crytic_compile.src_content:
179            self.source_code[path] = self.crytic_compile.src_content[path]
180        else:
181            with open(path, encoding="utf8", newline="") as f:
182                self.source_code[path] = f.read()
183
184        self.parse_ignore_comments(path)
185
186    @property
187    def markdown_root(self) -> str:
188        return self._markdown_root
189
190    def print_functions(self, d: str):
191        """
192        Export all the functions to dot files
193        """
194        for compilation_unit in self._compilation_units:
195            for c in compilation_unit.contracts:
196                for f in c.functions:
197                    f.cfg_to_dot(os.path.join(d, f"{c.name}.{f.name}.dot"))
198
199    def _compute_offsets_from_thing(self, thing: SourceMapping):
200        definition = get_definition(thing, self.crytic_compile)
201        references = get_references(thing)
202        implementations = get_all_implementations(thing, self.contracts)
203
204        # Create the offset mapping
205        for offset in range(definition.start, definition.end + 1):
206            self._offset_to_min_offset[definition.filename][offset].add(definition.start)
207
208        is_declared_function = (
209            isinstance(thing, FunctionContract) and thing.contract_declarer == thing.contract
210        )
211
212        should_add_to_objects = (
213            isinstance(thing, (TopLevel, Contract))
214            or is_declared_function
215            or (isinstance(thing, ContractLevel) and not isinstance(thing, FunctionContract))
216        )
217
218        if should_add_to_objects:
219            self._offset_to_objects[definition.filename][definition.start].add(thing)
220
221        self._offset_to_definitions[definition.filename][definition.start].add(definition)
222        self._offset_to_implementations[definition.filename][definition.start].update(
223            implementations
224        )
225        self._offset_to_references[definition.filename][definition.start] |= set(references)
226
227        # For references
228        should_add_to_objects = (
229            isinstance(thing, TopLevel)
230            or is_declared_function
231            or (isinstance(thing, ContractLevel) and not isinstance(thing, FunctionContract))
232        )
233
234        for ref in references:
235            for offset in range(ref.start, ref.end + 1):
236                self._offset_to_min_offset[definition.filename][offset].add(ref.start)
237
238            if should_add_to_objects:
239                self._offset_to_objects[definition.filename][ref.start].add(thing)
240
241            if is_declared_function:
242                # Only show the nearest lexical definition for declared contract-level functions
243                if (
244                    thing.contract.source_mapping.start
245                    < ref.start
246                    < thing.contract.source_mapping.end
247                ):
248
249                    self._offset_to_definitions[ref.filename][ref.start].add(definition)
250
251            else:
252                self._offset_to_definitions[ref.filename][ref.start].add(definition)
253
254            self._offset_to_implementations[ref.filename][ref.start].update(implementations)
255            self._offset_to_references[ref.filename][ref.start] |= set(references)
256
257    def _compute_offsets_to_ref_impl_decl(self):  # pylint: disable=too-many-branches
258        self._offset_to_references = defaultdict(lambda: defaultdict(lambda: set()))
259        self._offset_to_definitions = defaultdict(lambda: defaultdict(lambda: set()))
260        self._offset_to_implementations = defaultdict(lambda: defaultdict(lambda: set()))
261        self._offset_to_objects = defaultdict(lambda: defaultdict(lambda: set()))
262        self._offset_to_min_offset = defaultdict(lambda: defaultdict(lambda: set()))
263
264        for compilation_unit in self._compilation_units:
265            for contract in compilation_unit.contracts:
266                self._compute_offsets_from_thing(contract)
267
268                for function in contract.functions_declared:
269                    self._compute_offsets_from_thing(function)
270                    for variable in function.local_variables:
271                        self._compute_offsets_from_thing(variable)
272                for modifier in contract.modifiers_declared:
273                    self._compute_offsets_from_thing(modifier)
274                    for variable in modifier.local_variables:
275                        self._compute_offsets_from_thing(variable)
276
277                for var in contract.state_variables:
278                    self._compute_offsets_from_thing(var)
279
280                for st in contract.structures:
281                    self._compute_offsets_from_thing(st)
282
283                for enum in contract.enums:
284                    self._compute_offsets_from_thing(enum)
285
286                for event in contract.events:
287                    self._compute_offsets_from_thing(event)
288
289                for typ in contract.type_aliases:
290                    self._compute_offsets_from_thing(typ)
291
292            for enum in compilation_unit.enums_top_level:
293                self._compute_offsets_from_thing(enum)
294            for event in compilation_unit.events_top_level:
295                self._compute_offsets_from_thing(event)
296            for function in compilation_unit.functions_top_level:
297                self._compute_offsets_from_thing(function)
298            for st in compilation_unit.structures_top_level:
299                self._compute_offsets_from_thing(st)
300            for var in compilation_unit.variables_top_level:
301                self._compute_offsets_from_thing(var)
302            for typ in compilation_unit.type_aliases.values():
303                self._compute_offsets_from_thing(typ)
304            for err in compilation_unit.custom_errors:
305                self._compute_offsets_from_thing(err)
306            for event in compilation_unit.events_top_level:
307                self._compute_offsets_from_thing(event)
308            for import_directive in compilation_unit.import_directives:
309                self._compute_offsets_from_thing(import_directive)
310            for pragma in compilation_unit.pragma_directives:
311                self._compute_offsets_from_thing(pragma)
312
313    T = TypeVar("T", Source, SourceMapping)
314
315    def _get_offset(
316        self, mapping: Dict[Filename, Dict[int, Set[T]]], filename_str: str, offset: int
317    ) -> Set[T]:
318        """Get the Source/SourceMapping referenced by the offset.
319
320        For performance reasons, references are only stored once at the lowest offset.
321        It uses the _offset_to_min_offset mapping to retrieve the correct offsets.
322        As multiple definitions can be related to the same offset, we retrieve all of them.
323
324        :param mapping: Mapping to search for (objects. references, ...)
325        :param filename_str: Filename to consider
326        :param offset: Look-up offset
327        :raises IndexError: When the start offset is not found
328        :return: The corresponding set of Source/SourceMapping
329        """
330        filename: Filename = self.crytic_compile.filename_lookup(filename_str)
331
332        start_offsets = self._offset_to_min_offset[filename][offset]
333        if not start_offsets:
334            msg = f"Unable to find reference for offset {offset}"
335            raise IndexError(msg)
336
337        results = set()
338        for start_offset in start_offsets:
339            results |= mapping[filename][start_offset]
340
341        return results
342
343    def offset_to_references(self, filename_str: str, offset: int) -> Set[Source]:
344        if self._offset_to_references is None:
345            self._compute_offsets_to_ref_impl_decl()
346
347        return self._get_offset(self._offset_to_references, filename_str, offset)
348
349    def offset_to_implementations(self, filename_str: str, offset: int) -> Set[Source]:
350        if self._offset_to_implementations is None:
351            self._compute_offsets_to_ref_impl_decl()
352
353        return self._get_offset(self._offset_to_implementations, filename_str, offset)
354
355    def offset_to_definitions(self, filename_str: str, offset: int) -> Set[Source]:
356        if self._offset_to_definitions is None:
357            self._compute_offsets_to_ref_impl_decl()
358
359        return self._get_offset(self._offset_to_definitions, filename_str, offset)
360
361    def offset_to_objects(self, filename_str: str, offset: int) -> Set[SourceMapping]:
362        if self._offset_to_objects is None:
363            self._compute_offsets_to_ref_impl_decl()
364
365        return self._get_offset(self._offset_to_objects, filename_str, offset)
366
367    # endregion
368    ###################################################################################
369    ###################################################################################
370    # region Filtering results
371    ###################################################################################
372    ###################################################################################
373
374    def parse_ignore_comments(self, file: str) -> None:
375        # The first time we check a file, find all start/end ignore comments and memoize them.
376        line_number = 1
377        while True:
378
379            line_text = self.crytic_compile.get_code_from_line(file, line_number)
380            if line_text is None:
381                break
382
383            start_regex = r"^\s*//\s*slither-disable-start\s*([a-zA-Z0-9_,-]*)"
384            end_regex = r"^\s*//\s*slither-disable-end\s*([a-zA-Z0-9_,-]*)"
385            start_match = re.findall(start_regex, line_text.decode("utf8"))
386            end_match = re.findall(end_regex, line_text.decode("utf8"))
387
388            if start_match:
389                ignored = start_match[0].split(",")
390                if ignored:
391                    for check in ignored:
392                        vals = self._ignore_ranges[file][check]
393                        if len(vals) == 0 or vals[-1][1] != float("inf"):
394                            # First item in the array, or the prior item is fully populated.
395                            self._ignore_ranges[file][check].append((line_number, float("inf")))
396                        else:
397                            logger.error(
398                                f"Consecutive slither-disable-starts without slither-disable-end in {file}#{line_number}"
399                            )
400                            return
401
402            if end_match:
403                ignored = end_match[0].split(",")
404                if ignored:
405                    for check in ignored:
406                        vals = self._ignore_ranges[file][check]
407                        if len(vals) == 0 or vals[-1][1] != float("inf"):
408                            logger.error(
409                                f"slither-disable-end without slither-disable-start in {file}#{line_number}"
410                            )
411                            return
412                        self._ignore_ranges[file][check][-1] = (vals[-1][0], line_number)
413
414            line_number += 1
415
416    def has_ignore_comment(self, r: Dict) -> bool:
417        """
418        Check if the result has an ignore comment in the file or on the preceding line, in which
419        case, it is not valid
420        """
421        if not self.crytic_compile:
422            return False
423        mapping_elements_with_lines = (
424            (
425                posixpath.normpath(elem["source_mapping"]["filename_absolute"]),
426                elem["source_mapping"]["lines"],
427            )
428            for elem in r["elements"]
429            if "source_mapping" in elem
430            and "filename_absolute" in elem["source_mapping"]
431            and "lines" in elem["source_mapping"]
432            and len(elem["source_mapping"]["lines"]) > 0
433        )
434
435        for file, lines in mapping_elements_with_lines:
436
437            # Check if result is within an ignored range.
438            ignore_ranges = self._ignore_ranges[file][r["check"]] + self._ignore_ranges[file]["all"]
439            for start, end in ignore_ranges:
440                # The full check must be within the ignore range to be ignored.
441                if start < lines[0] and end > lines[-1]:
442                    return True
443
444            # Check for next-line matchers.
445            ignore_line_index = min(lines) - 1
446            ignore_line_text = self.crytic_compile.get_code_from_line(file, ignore_line_index)
447            if ignore_line_text:
448                match = re.findall(
449                    r"^\s*//\s*slither-disable-next-line\s*([a-zA-Z0-9_,-]*)",
450                    ignore_line_text.decode("utf8"),
451                )
452                if match:
453                    ignored = match[0].split(",")
454                    if ignored and ("all" in ignored or any(r["check"] == c for c in ignored)):
455                        return True
456
457        return False
458
459    def valid_result(self, r: Dict) -> bool:
460        """
461        Check if the result is valid
462        A result is invalid if:
463            - All its source paths belong to the source path filtered
464            - Or a similar result was reported and saved during a previous run
465            - The --exclude-dependencies flag is set and results are only related to dependencies
466            - There is an ignore comment on the preceding line or in the file
467        """
468
469        # Remove duplicate due to the multiple compilation support
470        if r["id"] in self._currently_seen_resuts:
471            return False
472        self._currently_seen_resuts.add(r["id"])
473
474        source_mapping_elements = [
475            elem["source_mapping"].get("filename_absolute", "unknown")
476            for elem in r["elements"]
477            if "source_mapping" in elem
478        ]
479
480        # Use POSIX-style paths so that filter_paths|include_paths works across different
481        # OSes. Convert to a list so elements don't get consumed and are lost
482        # while evaluating the first pattern
483        source_mapping_elements = list(
484            map(lambda x: pathlib.Path(x).resolve().as_posix() if x else x, source_mapping_elements)
485        )
486        (matching, paths, msg_err) = (
487            (True, self._paths_to_include, "--include-paths")
488            if self._paths_to_include
489            else (False, self._paths_to_filter, "--filter-paths")
490        )
491
492        for path in paths:
493            try:
494                if any(
495                    bool(re.search(_relative_path_format(path), src_mapping))
496                    for src_mapping in source_mapping_elements
497                ):
498                    matching = not matching
499                    break
500            except re.error:
501                logger.error(
502                    f"Incorrect regular expression for {msg_err} {path}."
503                    "\nSlither supports the Python re format"
504                    ": https://docs.python.org/3/library/re.html"
505                )
506
507        if r["elements"] and matching:
508            return False
509
510        if self._show_ignored_findings:
511            return True
512        if self.has_ignore_comment(r):
513            return False
514        if r["id"] in self._previous_results_ids:
515            return False
516        if r["elements"] and self._exclude_dependencies:
517            if all(element["source_mapping"]["is_dependency"] for element in r["elements"]):
518                return False
519        # Conserve previous result filtering. This is conserved for compatibility, but is meant to be removed
520        if r["description"] in [pr["description"] for pr in self._previous_results]:
521            return False
522
523        return True
524
525    def load_previous_results(self) -> None:
526        self.load_previous_results_from_sarif()
527
528        filename = self._previous_results_filename
529        try:
530            if os.path.isfile(filename):
531                with open(filename, encoding="utf8") as f:
532                    self._previous_results = json.load(f)
533                    if self._previous_results:
534                        for r in self._previous_results:
535                            if "id" in r:
536                                self._previous_results_ids.add(r["id"])
537
538        except json.decoder.JSONDecodeError:
539            logger.error(red(f"Impossible to decode {filename}. Consider removing the file"))
540
541    def load_previous_results_from_sarif(self) -> None:
542        sarif = pathlib.Path(self.sarif_input)
543        triage = pathlib.Path(self.sarif_triage)
544
545        if not sarif.exists():
546            return
547        if not triage.exists():
548            return
549
550        triaged = read_triage_info(sarif, triage)
551
552        for id_triaged in triaged:
553            self._previous_results_ids.add(id_triaged)
554
555    def write_results_to_hide(self) -> None:
556        if not self._results_to_hide:
557            return
558        filename = self._previous_results_filename
559        with open(filename, "w", encoding="utf8") as f:
560            results = self._results_to_hide + self._previous_results
561            json.dump(results, f)
562
563    def save_results_to_hide(self, results: List[Dict]) -> None:
564        self._results_to_hide += results
565        self.write_results_to_hide()
566
567    def add_path_to_filter(self, path: str):
568        """
569        Add path to filter
570        Path are used through direct comparison (no regex)
571        """
572        self._paths_to_filter.add(path)
573
574    def add_path_to_include(self, path: str):
575        """
576        Add path to include
577        Path are used through direct comparison (no regex)
578        """
579        self._paths_to_include.add(path)
580
581    # endregion
582    ###################################################################################
583    ###################################################################################
584    # region Crytic compile
585    ###################################################################################
586    ###################################################################################
587
588    @property
589    def crytic_compile(self) -> CryticCompile:
590        return self._crytic_compile  # type: ignore
591
592    # endregion
593    ###################################################################################
594    ###################################################################################
595    # region Format
596    ###################################################################################
597    ###################################################################################
598
599    @property
600    def generate_patches(self) -> bool:
601        return self._generate_patches
602
603    @generate_patches.setter
604    def generate_patches(self, p: bool):
605        self._generate_patches = p
606
607    # endregion
608    ###################################################################################
609    ###################################################################################
610    # region Internals
611    ###################################################################################
612    ###################################################################################
613
614    @property
615    def disallow_partial(self) -> bool:
616        """
617        Return true if partial analyses are disallowed
618        For example, codebase with duplicate names will lead to partial analyses
619
620        :return:
621        """
622        return self._disallow_partial
623
624    @property
625    def skip_assembly(self) -> bool:
626        return self._skip_assembly
627
628    @property
629    def show_ignore_findings(self) -> bool:
630        return self._show_ignored_findings
631
632    # endregion