slither.utils.command_line

  1import argparse
  2import enum
  3import json
  4import os
  5import re
  6import logging
  7from collections import defaultdict
  8from typing import Dict, List, Type, Union
  9
 10from crytic_compile.cryticparser.defaults import (
 11    DEFAULTS_FLAG_IN_CONFIG as DEFAULTS_FLAG_IN_CONFIG_CRYTIC_COMPILE,
 12)
 13
 14from slither.detectors.abstract_detector import classification_txt, AbstractDetector
 15from slither.printers.abstract_printer import AbstractPrinter
 16from slither.utils.colors import yellow, red
 17from slither.utils.myprettytable import MyPrettyTable
 18
 19logger = logging.getLogger("Slither")
 20
 21DEFAULT_JSON_OUTPUT_TYPES = ["detectors", "printers"]
 22JSON_OUTPUT_TYPES = [
 23    "compilations",
 24    "console",
 25    "detectors",
 26    "printers",
 27    "list-detectors",
 28    "list-printers",
 29]
 30
 31
 32class FailOnLevel(enum.Enum):
 33    PEDANTIC = "pedantic"
 34    LOW = "low"
 35    MEDIUM = "medium"
 36    HIGH = "high"
 37    NONE = "none"
 38
 39
 40# Those are the flags shared by the command line and the config file
 41defaults_flag_in_config = {
 42    "codex": False,
 43    "codex_contracts": "all",
 44    "codex_model": "text-davinci-003",
 45    "codex_temperature": 0,
 46    "codex_max_tokens": 300,
 47    "codex_log": False,
 48    "detectors_to_run": "all",
 49    "printers_to_run": None,
 50    "detectors_to_exclude": None,
 51    "exclude_dependencies": False,
 52    "exclude_informational": False,
 53    "exclude_optimization": False,
 54    "exclude_low": False,
 55    "exclude_medium": False,
 56    "exclude_high": False,
 57    "fail_on": FailOnLevel.PEDANTIC,
 58    "json": None,
 59    "sarif": None,
 60    "json-types": ",".join(DEFAULT_JSON_OUTPUT_TYPES),
 61    "disable_color": False,
 62    "filter_paths": None,
 63    "include_paths": None,
 64    "generate_patches": False,
 65    # debug command
 66    "skip_assembly": False,
 67    "legacy_ast": False,
 68    "zip": None,
 69    "zip_type": "lzma",
 70    "show_ignored_findings": False,
 71    "no_fail": False,
 72    "sarif_input": "export.sarif",
 73    "sarif_triage": "export.sarif.sarifexplorer",
 74    "triage_database": "slither.db.json",
 75    **DEFAULTS_FLAG_IN_CONFIG_CRYTIC_COMPILE,
 76}
 77
 78deprecated_flags = {
 79    "fail_pedantic": True,
 80    "fail_low": False,
 81    "fail_medium": False,
 82    "fail_high": False,
 83}
 84
 85
 86def read_config_file(args: argparse.Namespace) -> None:
 87    # No config file was provided as an argument
 88    if args.config_file is None:
 89        # Check wether the default config file is present
 90        if os.path.exists("slither.config.json"):
 91            # The default file exists, use it
 92            args.config_file = "slither.config.json"
 93        else:
 94            return
 95
 96    if os.path.isfile(args.config_file):
 97        try:
 98            with open(args.config_file, encoding="utf8") as f:
 99                config = json.load(f)
100                for key, elem in config.items():
101                    if key in deprecated_flags:
102                        logger.info(
103                            yellow(f"{args.config_file} has a deprecated key: {key} : {elem}")
104                        )
105                        migrate_config_options(args, key, elem)
106                        continue
107                    if key not in defaults_flag_in_config:
108                        logger.info(
109                            yellow(f"{args.config_file} has an unknown key: {key} : {elem}")
110                        )
111                        continue
112                    if getattr(args, key) == defaults_flag_in_config[key]:
113                        setattr(args, key, elem)
114        except json.decoder.JSONDecodeError as e:
115            logger.error(red(f"Impossible to read {args.config_file}, please check the file {e}"))
116    else:
117        logger.error(red(f"File {args.config_file} is not a file or does not exist"))
118        logger.error(yellow("Falling back to the default settings..."))
119
120
121def migrate_config_options(args: argparse.Namespace, key: str, elem):
122    if key.startswith("fail_") and getattr(args, "fail_on") == defaults_flag_in_config["fail_on"]:
123        if key == "fail_pedantic":
124            pedantic_setting = elem
125            fail_on = FailOnLevel.PEDANTIC if pedantic_setting else FailOnLevel.NONE
126            setattr(args, "fail_on", fail_on)
127            logger.info(f"Migrating fail_pedantic: {pedantic_setting} as fail_on: {fail_on.value}")
128        elif key == "fail_low" and elem is True:
129            logger.info("Migrating fail_low: true -> fail_on: low")
130            setattr(args, "fail_on", FailOnLevel.LOW)
131
132        elif key == "fail_medium" and elem is True:
133            logger.info("Migrating fail_medium: true -> fail_on: medium")
134            setattr(args, "fail_on", FailOnLevel.MEDIUM)
135
136        elif key == "fail_high" and elem is True:
137            logger.info("Migrating fail_high: true -> fail_on: high")
138            setattr(args, "fail_on", FailOnLevel.HIGH)
139        else:
140            logger.warning(yellow(f"Key {key} was deprecated but no migration was provided"))
141
142
143def output_to_markdown(
144    detector_classes: List[Type[AbstractDetector]],
145    printer_classes: List[Type[AbstractPrinter]],
146    filter_wiki: str,
147) -> None:
148    def extract_help(cls: Union[Type[AbstractDetector], Type[AbstractPrinter]]) -> str:
149        if cls.WIKI == "":
150            return cls.HELP
151        return f"[{cls.HELP}]({cls.WIKI})"
152
153    detectors_list = []
154    print(filter_wiki)
155    for detector in detector_classes:
156        argument = detector.ARGUMENT
157        # dont show the backdoor example
158        if argument == "backdoor":
159            continue
160        if not filter_wiki in detector.WIKI:
161            continue
162        help_info = extract_help(detector)
163        impact = detector.IMPACT
164        confidence = classification_txt[detector.CONFIDENCE]
165        detectors_list.append((argument, help_info, impact, confidence))
166
167    # Sort by impact, confidence, and name
168    detectors_list = sorted(
169        detectors_list, key=lambda element: (element[2], element[3], element[0])
170    )
171    idx = 1
172    for (argument, help_info, impact, confidence) in detectors_list:
173        print(f"{idx} | `{argument}` | {help_info} | {classification_txt[impact]} | {confidence}")
174        idx = idx + 1
175
176    print()
177    printers_list = []
178    for printer in printer_classes:
179        argument = printer.ARGUMENT
180        help_info = extract_help(printer)
181        printers_list.append((argument, help_info))
182
183    # Sort by impact, confidence, and name
184    printers_list = sorted(printers_list, key=lambda element: (element[0]))
185    idx = 1
186    for (argument, help_info) in printers_list:
187        print(f"{idx} | `{argument}` | {help_info}")
188        idx = idx + 1
189
190
191def get_level(l: str) -> int:
192    tab = l.count("\t") + 1
193    if l.replace("\t", "").startswith(" -"):
194        tab = tab + 1
195    if l.replace("\t", "").startswith("-"):
196        tab = tab + 1
197    return tab
198
199
200def convert_result_to_markdown(txt: str) -> str:
201    # -1 to remove the last \n
202    lines = txt[0:-1].split("\n")
203    ret = []
204    level = 0
205    for l in lines:
206        next_level = get_level(l)
207        prefix = "<li>"
208        if next_level < level:
209            prefix = "</ul>" * (level - next_level) + prefix
210        if next_level > level:
211            prefix = "<ul>" * (next_level - level) + prefix
212        level = next_level
213        ret.append(prefix + l)
214
215    return "".join(ret)
216
217
218def output_results_to_markdown(
219    all_results: List[Dict], checklistlimit: str, show_ignored_findings: bool
220) -> None:
221    checks = defaultdict(list)
222    info: Dict = defaultdict(dict)
223    for results_ in all_results:
224        checks[results_["check"]].append(results_)
225        info[results_["check"]] = {
226            "impact": results_["impact"],
227            "confidence": results_["confidence"],
228        }
229
230    if not show_ignored_findings:
231        print(
232            "**THIS CHECKLIST IS NOT COMPLETE**. Use `--show-ignored-findings` to show all the results."
233        )
234
235    print("Summary")
236    for check_ in checks:
237        print(
238            f" - [{check_}](#{check_}) ({len(checks[check_])} results) ({info[check_]['impact']})"
239        )
240
241    counter = 0
242    for (check, results) in checks.items():
243        print(f"## {check}")
244        print(f'Impact: {info[check]["impact"]}')
245        print(f'Confidence: {info[check]["confidence"]}')
246        additional = False
247        if checklistlimit and len(results) > 5:
248            results = results[0:5]
249            additional = True
250        for result in results:
251            print(" - [ ] ID-" + f"{counter}")
252            counter = counter + 1
253            print(result["markdown"])
254            if result["first_markdown_element"]:
255                print(result["first_markdown_element"])
256                print("\n")
257        if additional:
258            print(f"**More results were found, check [{checklistlimit}]({checklistlimit})**")
259
260
261def output_wiki(detector_classes: List[Type[AbstractDetector]], filter_wiki: str) -> None:
262
263    # Sort by impact, confidence, and name
264    detectors_list = sorted(
265        detector_classes,
266        key=lambda element: (element.IMPACT, element.CONFIDENCE, element.ARGUMENT),
267    )
268
269    for detector in detectors_list:
270        argument = detector.ARGUMENT
271        # dont show the backdoor example
272        if argument == "backdoor":
273            continue
274        if not filter_wiki in detector.WIKI:
275            continue
276        check = detector.ARGUMENT
277        impact = classification_txt[detector.IMPACT]
278        confidence = classification_txt[detector.CONFIDENCE]
279        title = detector.WIKI_TITLE
280        description = detector.WIKI_DESCRIPTION
281        exploit_scenario = detector.WIKI_EXPLOIT_SCENARIO
282        recommendation = detector.WIKI_RECOMMENDATION
283
284        print(f"\n## {title}")
285        print("### Configuration")
286        print(f"* Check: `{check}`")
287        print(f"* Severity: `{impact}`")
288        print(f"* Confidence: `{confidence}`")
289        print("\n### Description")
290        print(description)
291        if exploit_scenario:
292            print("\n### Exploit Scenario:")
293            print(exploit_scenario)
294        print("\n### Recommendation")
295        print(recommendation)
296
297
298def output_detectors(detector_classes: List[Type[AbstractDetector]]) -> None:
299    detectors_list = []
300    for detector in detector_classes:
301        argument = detector.ARGUMENT
302        # dont show the backdoor example
303        if argument == "backdoor":
304            continue
305        help_info = detector.HELP
306        impact = detector.IMPACT
307        confidence = classification_txt[detector.CONFIDENCE]
308        detectors_list.append((argument, help_info, impact, confidence))
309    table = MyPrettyTable(["Num", "Check", "What it Detects", "Impact", "Confidence"])
310
311    # Sort by impact, confidence, and name
312    detectors_list = sorted(
313        detectors_list, key=lambda element: (element[2], element[3], element[0])
314    )
315    idx = 1
316    for (argument, help_info, impact, confidence) in detectors_list:
317        table.add_row([str(idx), argument, help_info, classification_txt[impact], confidence])
318        idx = idx + 1
319    print(table)
320
321
322# pylint: disable=too-many-locals
323def output_detectors_json(
324    detector_classes: List[Type[AbstractDetector]],
325) -> List[Dict]:
326    detectors_list = []
327    for detector in detector_classes:
328        argument = detector.ARGUMENT
329        # dont show the backdoor example
330        if argument == "backdoor":
331            continue
332        help_info = detector.HELP
333        impact = detector.IMPACT
334        confidence = classification_txt[detector.CONFIDENCE]
335        wiki_url = detector.WIKI
336        wiki_description = detector.WIKI_DESCRIPTION
337        wiki_exploit_scenario = detector.WIKI_EXPLOIT_SCENARIO
338        wiki_recommendation = detector.WIKI_RECOMMENDATION
339        detectors_list.append(
340            (
341                argument,
342                help_info,
343                impact,
344                confidence,
345                wiki_url,
346                wiki_description,
347                wiki_exploit_scenario,
348                wiki_recommendation,
349            )
350        )
351
352    # Sort by impact, confidence, and name
353    detectors_list = sorted(
354        detectors_list, key=lambda element: (element[2], element[3], element[0])
355    )
356    idx = 1
357    table = []
358    for (
359        argument,
360        help_info,
361        impact,
362        confidence,
363        wiki_url,
364        description,
365        exploit,
366        recommendation,
367    ) in detectors_list:
368        table.append(
369            {
370                "index": idx,
371                "check": argument,
372                "title": help_info,
373                "impact": classification_txt[impact],
374                "confidence": confidence,
375                "wiki_url": wiki_url,
376                "description": description,
377                "exploit_scenario": exploit,
378                "recommendation": recommendation,
379            }
380        )
381        idx = idx + 1
382    return table
383
384
385def output_printers(printer_classes: List[Type[AbstractPrinter]]) -> None:
386    printers_list = []
387    for printer in printer_classes:
388        argument = printer.ARGUMENT
389        help_info = printer.HELP
390        printers_list.append((argument, help_info))
391    table = MyPrettyTable(["Num", "Printer", "What it Does"])
392
393    # Sort by impact, confidence, and name
394    printers_list = sorted(printers_list, key=lambda element: (element[0]))
395    idx = 1
396    for (argument, help_info) in printers_list:
397        table.add_row([str(idx), argument, help_info])
398        idx = idx + 1
399    print(table)
400
401
402def output_printers_json(printer_classes: List[Type[AbstractPrinter]]) -> List[Dict]:
403    printers_list = []
404    for printer in printer_classes:
405        argument = printer.ARGUMENT
406        help_info = printer.HELP
407
408        printers_list.append((argument, help_info))
409
410    # Sort by name
411    printers_list = sorted(printers_list, key=lambda element: (element[0]))
412    idx = 1
413    table = []
414    for (argument, help_info) in printers_list:
415        table.append({"index": idx, "check": argument, "title": help_info})
416        idx = idx + 1
417    return table
418
419
420def check_and_sanitize_markdown_root(markdown_root: str) -> str:
421    # Regex to check whether the markdown_root is a GitHub URL
422    match = re.search(
423        r"(https://)github.com/([a-zA-Z-]+)([:/][A-Za-z0-9_.-]+[:/]?)([A-Za-z0-9_.-]*)(.*)",
424        markdown_root,
425    )
426    if match:
427        if markdown_root[-1] != "/":
428            logger.warning("Appending '/' in markdown_root url for better code referencing")
429            markdown_root = markdown_root + "/"
430
431        if not match.group(4):
432            logger.warning(
433                "Appending 'master/tree/' in markdown_root url for better code referencing"
434            )
435            markdown_root = markdown_root + "master/tree/"
436        elif match.group(4) == "tree":
437            logger.warning(
438                "Replacing 'tree' with 'blob' in markdown_root url for better code referencing"
439            )
440            positions = match.span(4)
441            markdown_root = f"{markdown_root[:positions[0]]}blob{markdown_root[positions[1]:]}"
442
443    return markdown_root