Merge pull request diffblue#50 from diffblue/marek/update_of_python_driver_PR

Marek/update of python driver of the whole analyser.

Author: marek-trtik

security-scanner/analyser.py

@@ -1,27 +1,26 @@
 import os
 import time
 import json
+import shutil
 
 
 def __get_my_dir(): return os.path.dirname(os.path.realpath(__file__))
 
 
-def get_possible_analyser_binary_pathnames():
-    result = []
-    for rdir in ["./", "../src/driver"]:
-        fname = os.path.abspath(os.path.join(__get_my_dir(), rdir, "security-analyzer"))
-        result.append(fname)
-    return result
+def get_security_analyser_pathname():
+    return os.path.abspath(os.path.join(__get_my_dir(), "../src/driver/security-analyzer"))
 
+def get_goto_instrument_pathname():
+    return os.path.abspath(os.path.join(__get_my_dir(), "../cbmc/src/goto-instrument/goto-instrument"))
 
-def get_analyser_binary_pathname():
-    for fname in get_possible_analyser_binary_pathnames():
-        if os.path.exists(fname) and os.path.isfile(fname):
-            return fname
-    return None
+def get_cbmc_pathname():
+    return os.path.abspath(os.path.join(__get_my_dir(), "../cbmc/src/cbmc/cbmc"))
 
+def get_symex_pathname():
+    return os.path.abspath(os.path.join(__get_my_dir(), "../cbmc/src/symex/symex"))
 
-def run_analyser(
+
+def run_security_analyser(
         root_jar,
         transition_rules_file_pathname,
         timeout,
@@ -33,23 +32,23 @@ def run_analyser(
         results_dir,
         temp_root_dir
         ):
-    prof = { "duration": time.time() }
+    prof = {}
+    prof_start_time = time.time()
+
     if not os.path.exists(results_dir):
         os.makedirs(results_dir)
 
     # Building the program JSON file (the list of all JARs application consists of) for the security analyser
     program_json_fname = os.path.abspath(os.path.join(results_dir, "program.json"))
     print("Building the program JSON file (the list of all JARs application consists of) for the 'goto-analyser': "
           + program_json_fname)
-    program_json_file = open(program_json_fname,"w")
-    program_jars_list = [ os.path.relpath(root_jar,results_dir) ]
-    program_json_file.write(json.dumps(program_jars_list,sort_keys=True,indent=4))
-    program_json_file.close()
+    with open(program_json_fname,"w") as program_json_file:
+        program_jars_list = [ os.path.relpath(root_jar,results_dir) ]
+        program_json_file.write(json.dumps(program_jars_list,sort_keys=True,indent=4))
 
     # Building the root config file for the security analyser
     root_config_json_fname = os.path.abspath(os.path.join(results_dir, "config.json"))
     print("Building the root config JSON file for 'goto-analyser': " + root_config_json_fname)
-    root_config_json_file = open(root_config_json_fname,"w")
     root_config_json = {
         "program": "./program.json",
         "rules": os.path.relpath(transition_rules_file_pathname,results_dir),
@@ -77,27 +76,142 @@ def run_analyser(
         root_config_json["dump_html_program"] = True
     else:
         root_config_json["dump_html_program"] = False
-    root_config_json_file.write(json.dumps(root_config_json,sort_keys=True,indent=4))
-    root_config_json_file.close()
+    with open(root_config_json_fname, "w") as root_config_json_file:
+        root_config_json_file.write(json.dumps(root_config_json, sort_keys=True, indent=4))
 
     if not os.path.exists(results_dir):
         os.makedirs(results_dir)
 
     old_cwd = os.getcwd()
     os.chdir(results_dir)
     command = (
-        get_analyser_binary_pathname() + " "
+        get_security_analyser_pathname() + " "
         + "'./" + os.path.relpath(root_jar,results_dir) + "' "
         "--security-scanner '" + os.path.relpath(root_config_json_fname,results_dir) + "' "
         )
-    prof["calling_goto_analyser"] = { "duration": time.time() }
-    print("Invoking 'security_analyser' ...")
+    prof["calling_goto_analyser"] = {}
+    prof_calling_goto_analyser_start_time = time.time()
+    print("Invoking 'security-analyser' ...")
     if verbosity >= 9:
         print("CWD: " + results_dir)
         print("CMD: " + command)
     os.system(command)
-    prof["calling_goto_analyser"]["duration"] = time.time() - prof["calling_goto_analyser"]["duration"]
+    prof["calling_goto_analyser"]["duration"] = time.time() - prof_calling_goto_analyser_start_time
     os.chdir(old_cwd)
-    prof["duration"] = time.time() - prof["duration"]
+    prof["duration"] = time.time() - prof_start_time
+
+    return prof
+
+
+def run_program_slicing(
+        json_cfg_fname,
+        results_dir,
+        timeout,
+        verbosity
+        ):
+    prof = {}
+    prof_start_time = time.time()
 
+    # TODO: once the slicer in "goto-instrument" tool is available, then provide proper implementation here!
+    #       Until then we assume the slicing removes nothing from the instrumented program.
+    shutil.copyfile(json_cfg_fname, os.path.join(os.path.dirname(json_cfg_fname),"sliced_goto_programs.json"))
+
+    prof["duration"] = time.time() - prof_start_time
     return prof
+
+
+def append_cbmc_error_trace_if_it_is_relevant(trace, trace_id, results_dir, cfg, traces_list):
+    """A trace is relevant, if it ends at a sink."""
+    was_trace_saved = False
+    last_rec = trace[-1]
+    if "sourceLocation" in last_rec:
+        loc = last_rec["sourceLocation"]
+        for sink in cfg["sinks"]:
+            if loc["file"] == sink["file"] and \
+                            loc["function"] == sink["function"] and \
+                            loc["line"] == str(sink["line"]):
+                trace_fname = os.path.join(results_dir, "error_trace_" + str(trace_id) + ".json")
+                with open(trace_fname, "w") as trace_file:
+                    trace_file.write(json.dumps(trace, sort_keys=False, indent=4))
+                was_trace_saved = True
+
+                found = False
+                for rec in traces_list:
+                    if rec["file"] == sink["file"] and \
+                                    rec["function"] == sink["function"] and \
+                                    rec["line"] == sink["line"] and \
+                                    rec["goto_binary_file"] == cfg["goto_binary_file"]:
+                        rec["error_traces"].append(trace_fname)
+                if found == False:
+                    rec = sink
+                    rec["goto_binary_file"] = cfg["goto_binary_file"]
+                    rec["error_traces"] = [trace_fname]
+                    traces_list.append(rec)
+                break
+    return was_trace_saved
+
+
+def run_search_for_error_traces(
+        json_cfg_fname,
+        results_dir,
+        timeout,
+        verbosity
+        ):
+    prof = {}
+    prof_start_time = time.time()
+    if not os.path.exists(results_dir):
+        os.makedirs(results_dir)
+
+    trace_id = 0
+    traces_list = []
+
+    with open(json_cfg_fname) as data_file:
+        cfgs = json.load(data_file)
+    for cfg in cfgs:
+        old_cwd = os.getcwd()
+        os.chdir(results_dir)
+        command = (
+            get_cbmc_pathname() + " " +
+            cfg["goto_binary_file"] + " " +
+            " --trace --lazy-methods --json-ui --unwind 10 " +
+            "--verbosity " + str(1) + " "
+            "> \"cbmc_results.json\""
+            )
+        prof["calling_cbmc"] = {}
+        prof_calling_cbmc_start_time = time.time()
+        print("Invoking 'cbmc' ...")
+        if verbosity >= 9:
+            print("CWD: " + results_dir)
+            print("CMD: " + command)
+        os.system(command)
+        prof["calling_cbmc"]["duration"] = time.time() - prof_calling_cbmc_start_time
+        os.chdir(old_cwd)
+
+        with open(os.path.join(results_dir,"cbmc_results.json")) as data_file:
+            cbmc_results = json.load(data_file)
+        for outer_element in cbmc_results:
+            if "result" in outer_element:
+                for inner_element in outer_element["result"]:
+                    if "trace" in inner_element and len(inner_element["trace"]) > 0:
+                        trace=inner_element["trace"]
+                        was_trace_saved = append_cbmc_error_trace_if_it_is_relevant(
+                                                trace,
+                                                trace_id,
+                                                results_dir,
+                                                cfg,
+                                                traces_list
+                                                )
+                        if was_trace_saved:
+                            trace_id += 1
+
+    with open(os.path.join(results_dir, "error_traces.json"), "w") as traces_file:
+        traces_file.write(json.dumps(traces_list, sort_keys=True, indent=4))
+
+    prof["duration"] = time.time() - prof_start_time
+    return prof
+
+
+
+
+if __name__ == "__main__":
+    pass

security-scanner/mkbench.py

@@ -9,16 +9,18 @@ def __get_my_dir(): return os.path.dirname(os.path.realpath(__file__))
 
 
 def collect_java_files(app_build_dir,extension_text,output_list):
-    prof = { "duration": time.time() }
+    prof = {}
+    prof_start_time = time.time()
     for root, dirnames, filenames in os.walk(app_build_dir):
         for filename in fnmatch.filter(filenames, "*." + extension_text):
             output_list.append(os.path.abspath(os.path.join(root,filename)))
-    prof["duration"] = time.time() - prof["duration"]
+    prof["duration"] = time.time() - prof_start_time
     return prof
 
 
 def unpack_java_package(pathname,unpack_dir):
-    prof = { "duration": time.time() }
+    prof = {}
+    prof_start_time = time.time()
     if not os.path.exists(unpack_dir):
         os.makedirs(unpack_dir)
     old_cwd = os.getcwd()
@@ -29,12 +31,13 @@ def unpack_java_package(pathname,unpack_dir):
         pathname
         )
     os.chdir(old_cwd)
-    prof["duration"] = time.time() - prof["duration"]
+    prof["duration"] = time.time() - prof_start_time
     return prof
 
 
 def pack_classes_to_jar(classes_dir,dst_file):
-    prof = { "duration": time.time() }
+    prof = {}
+    prof_start_time = time.time()
     if not os.path.exists(os.path.dirname(dst_file)):
         os.makedirs(os.path.dirname(dst_file))
     old_cwd = os.getcwd()
@@ -44,7 +47,7 @@ def pack_classes_to_jar(classes_dir,dst_file):
         + dst_file + "\" ."
         )
     os.chdir(old_cwd)
-    prof["duration"] = time.time() - prof["duration"]
+    prof["duration"] = time.time() - prof_start_time
     return prof
 
 
@@ -100,11 +103,13 @@ def is_class_modeled(pathname):
 
 
 def install_class_file(pathname,output_dir,class_temp_dir):
-    prof = { "duration": time.time() }
+    prof = {}
+    prof_start_time = time.time()
     print("   " + pathname)
-    prof["fullname"] = { "duration": time.time() }
+    prof["fullname"] = {}
+    prof_fullname_start_time = time.time()
     packages_classname = compute_fullname_of_class(pathname,class_temp_dir)
-    prof["fullname"]["duration"] = time.time() - prof["fullname"]["duration"]
+    prof["fullname"]["duration"] = time.time() - prof_fullname_start_time
     if packages_classname is None:
         print("FAIL: Cannot read full class name (including packages) of the class file: " + pathname)
         prof["duration"] = time.time() - prof["duration"]
@@ -120,12 +125,13 @@ def install_class_file(pathname,output_dir,class_temp_dir):
     else:
         shutil.copyfile(pathname,class_pathname)
 
-    prof["duration"] = time.time() - prof["duration"]
+    prof["duration"] = time.time() - prof_start_time
     return prof
 
 
 def install_jar_file(pathname,output_dir,temp_dir,class_temp_dir):
-    prof = { "duration": time.time() }
+    prof = {}
+    prof_start_time = time.time()
 
     prof["unpack"] = unpack_java_package(pathname,temp_dir)
 
@@ -140,12 +146,13 @@ def install_jar_file(pathname,output_dir,temp_dir,class_temp_dir):
         prof["install"]["duration"] += prof_install["duration"]
         prof["install"]["fullname"]["duration"] += prof_install["fullname"]["duration"]
 
-    prof["duration"] = time.time() - prof["duration"]
+    prof["duration"] = time.time() - prof_start_time
     return prof
 
 
 def install_war_file(pathname,output_dir,temp_dir,class_temp_dir):
-    prof = { "duration": time.time() }
+    prof = {}
+    prof_start_time = time.time()
 
     war_temp_dir = os.path.join(temp_dir,"WAR")
     prof["unpack"] = unpack_java_package(pathname,war_temp_dir)
@@ -176,12 +183,13 @@ def install_war_file(pathname,output_dir,temp_dir,class_temp_dir):
         prof["install"]["duration"] += prof_install["install"]["duration"]
         prof["install"]["fullname"]["duration"] += prof_install["install"]["fullname"]["duration"]
 
-    prof["duration"] = time.time() - prof["duration"]
+    prof["duration"] = time.time() - prof_start_time
     return prof
 
 
 def build_classes_configuration(app_binary_dir,output_dir,temp_dir):
-    prof = { "duration": time.time() }
+    prof = {}
+    prof_start_time = time.time()
 
     prof["unpack"] = {"duration": 0.0}
     prof["collect"] = {"duration": 0.0}
@@ -229,5 +237,5 @@ def build_classes_configuration(app_binary_dir,output_dir,temp_dir):
         prof["install"]["duration"] += prof_install["install"]["duration"]
         prof["install"]["fullname"]["duration"] += prof_install["install"]["fullname"]["duration"]
 
-    prof["duration"] = time.time() - prof["duration"]
+    prof["duration"] = time.time() - prof_start_time
     return prof