adapt TimeMachine for Themis

Author: the-themis-benchmarks

Dockerfile

@@ -7,8 +7,10 @@ MAINTAINER [email protected]
 WORKDIR /root
 ENV DEBIAN_FRONTEND noninteractive
 
-RUN  apt-get update && apt-get install -y linux-headers-$(uname -r) virtualbox-dkms virtualbox virtualbox-qt  python-pip openjdk-8-jdk git-core \
-     && pip install pyvbox enum vbox-sdk uiautomator  
+RUN  apt-get update && apt-get install -y linux-headers-$(uname -r) virtualbox-dkms virtualbox virtualbox-qt  python-pip python3-pip openjdk-8-jdk git-core \
+     && pip install pyvbox enum vbox-sdk uiautomator \
+     # uiautomator2's recent versions (v.2.10.1 - v2.9.6) failed; 2.4.3 at least works. The main issue is related to the version of atx-agent
+     && pip3 install -U uiautomator2==2.4.3	 
 
 
 #super important: setting enviroment variables

README.md

@@ -105,3 +105,53 @@ cat duolingo_output/timemachine-output/crashes.log
 * Abhik Roychoudhury
 
 
+# Some useful commands to debug TimeMachine
+
+1. view the GUI
+
+Set up the $HOME/.Xauthority (on my desktop, Ubuntu-18.04), see this [link](https://askubuntu.com/questions/21923/how-do-i-create-the-xauthority-file)
+```
+ln -s -f $Xauthority $HOME/.Xauthority
+``` 
+
+2. start the docker with GUI forwarding enabled
+
+```
+docker run -it --privileged -e DISPLAY=$DISPLAY --net=host -v $HOME/.Xauthority:/root/.Xauthority:rw -v /dev:/dev droidtest/timemachine:1.0
+```
+
+3. create, start, and power off the Android VM inside the docker
+```
+./setup_vm.bash Android7_1 5554
+
+VBoxManage startvm Android7_1 
+
+VBoxManage controlvm Android7_1 poweroff
+
+rm -rf /root/VirtualBox\ VMs/Android7_1/
+```
+
+I tried to resize the VM screen size. But it does not take effect. See this [link](https://superuser.com/questions/31669/change-resolution-from-command-line-in-virtual-box)
+```
+VBoxManage controlvm "Android7_1" setvideomodehint 1024 600 32
+```
+
+Show without GUI: 
+```
+VBoxManage startvm Android7_1 --type headless
+```
+
+4. connect to the Android VM
+```
+adb disconnect 127.0.0.1:5554
+
+adb connect 127.0.0.1:5554
+```
+
+5. Test uiautomator2 against Android VM (uiautomator2 v2.4.3 works)
+
+```
+pip3 install -U uiautomator2==2.4.3
+
+python3 -m uiautomator2 init
+```

fuzzingandroid/FuzzerEngine/fuzzerengine/config_fuzzer.py

@@ -13,6 +13,7 @@ class RunParameters:
 
     OUTPUT_FILE = "pareto0.log"
     CRASH_FILE = "pareto0.crash"
-    OPEN_SOURCE = False
+    RUN_TIME_FILE = "run_time.log"
+    OPEN_SOURCE = True
 
 

fuzzingandroid/FuzzerEngine/fuzzerengine/coverage_manager.py

@@ -5,7 +5,9 @@
 import time
 import threading
 import re
-from config_fuzzer import RunParameters 
+from xml.dom import minidom
+from xml.parsers.expat import ExpatError
+from config_fuzzer import RunParameters
 
 def get_emma_coverage(restore_count):
     # adb shell am broadcast -a edu.gatech.m3.emma.COLLECT_COVERAGE
@@ -15,51 +17,41 @@ def get_emma_coverage(restore_count):
     output, err = cmd.communicate()
     print 'get_emma_coverage- return code: ' + ' output: ' + str(output) + ' ' + str(err) +' '
 
+def get_jacoco_coverage(restore_count, app_package_name, app_class_files_path, avd_serial):
+    # adb shell am broadcast -a edu.gatech.m3.emma.COLLECT_COVERAGE
+    cov_file_name = 'coverage' + str(restore_count)
+
+    cmd = subprocess.Popen(['../../scripts/pull_coverage_jacoco.sh', cov_file_name, app_package_name, app_class_files_path, avd_serial],
+                           stdout = subprocess.PIPE, stderr = subprocess.PIPE)
+    output, err = cmd.communicate()
+    print 'get_jacoco_coverage- return code: ' + ' output: ' + str(output) + ' ' + str(err) +' '
+
 def get_ella_coverage(restore_count):
     cov_file_name = 'coverage' + str(restore_count)
-    
-        
+
+
     cmd = subprocess.Popen (['../../scripts/pull_coverage_ella.sh', cov_file_name],stdout = subprocess.PIPE, stderr = subprocess.PIPE)
     output, err = cmd.communicate()
-    print 'get_ella_coverage: return msg: error: ' + str(output) + ' ' + str(err) 
+    print 'get_ella_coverage: return msg: error: ' + str(output) + ' ' + str(err)
 
 def compute_coverage():
     #using compute_coverage to compute
     cmd = subprocess.Popen ('../../scripts/compute_coverage.sh',stdout = subprocess.PIPE, stderr = subprocess.PIPE)
     output, err=cmd.communicate()
     print 'compute_coverage-return code: ' + ' output: '+str(output) + '  ' + str(err) +' '
 
-def compute_coverage_ella():
+def compute_coverage_jacoco(app_class_files_path):
     #using compute_coverage to compute
-    
-    cmd = subprocess.Popen ('../../scripts/compute_coverage_ella.sh',stdout = subprocess.PIPE, stderr = subprocess.PIPE)
+    cmd = subprocess.Popen (['../../scripts/compute_coverage_jacoco.sh', app_class_files_path],stdout = subprocess.PIPE, stderr = subprocess.PIPE)
     output, err=cmd.communicate()
     print 'compute_coverage-return code: ' + ' output: '+str(output) + '  ' + str(err) +' '
 
-def read_coverage_ella():
-    if not os.path.isfile ('../../output/ella_files/cov'):
-        return 0
-    f= open ('../../output/ella_files/cov', 'r')
-    lines = f.readlines()
-    f.close()
-
-    return int(lines[0])
+def compute_coverage_ella():
+    #using compute_coverage to compute
 
-def read_current_coverage():
-    if RunParameters.OPEN_SOURCE:
-        return read_coverage()
-    else:
-        return read_coverage_ella()
-def compute_current_coverage():
-    if RunParameters.OPEN_SOURCE:
-        compute_coverage()
-    else:
-        compute_coverage_ella()
-def pull_coverage_files(restore_count):
-    if RunParameters.OPEN_SOURCE:
-        get_emma_coverage(restore_count)
-    else:
-        get_ella_coverage(restore_count)
+    cmd = subprocess.Popen ('../../scripts/compute_coverage_ella.sh',stdout = subprocess.PIPE, stderr = subprocess.PIPE)
+    output, err=cmd.communicate()
+    print 'compute_coverage-return code: ' + ' output: '+str(output) + '  ' + str(err) +' '
 
 def read_coverage():
     if not os.path.isfile('../../output/coverage.txt'):
@@ -82,6 +74,64 @@ def read_coverage():
 
     return int(s.replace("%", ""))
 
+def read_coverage_jacoco():
+    if not os.path.isfile('../../output/coverage.xml'):
+        return 0
+
+    try:
+        # see the format of coverage report generated by Jacoco in xml
+        xmldoc = minidom.parse('../../output/coverage.xml')
+        counters = xmldoc.getElementsByTagName('counter')
+        line_coverage = 0
+        for counter in counters:
+            type_name = counter.getAttribute('type')
+            if type_name == 'LINE':
+                missed_lines = int(counter.getAttribute('missed'))
+                covered_lines = int(counter.getAttribute('covered'))
+                line_coverage = covered_lines * 100.0 / (missed_lines + covered_lines)
+
+        if line_coverage == 0:
+            return 0
+        else:
+            print "-----------"
+            print "current jacoco line coverage: " + str(line_coverage)
+            print "-----------"
+            return line_coverage
+    except ExpatError:
+        print "parse xml error, catch it!"
+        return 0
+
+def read_coverage_ella():
+    if not os.path.isfile ('../../output/ella_files/cov'):
+        return 0
+    f= open ('../../output/ella_files/cov', 'r')
+    lines = f.readlines()
+    f.close()
+    print "[tingsu] current ella method coverage: " + str(lines[0])
+
+    return int(lines[0])
+
+def read_current_coverage():
+    if RunParameters.OPEN_SOURCE:
+        # return read_coverage()
+        return read_coverage_jacoco()
+    else:
+        return read_coverage_ella()
+
+def compute_current_coverage(app_class_files_path):
+    if RunParameters.OPEN_SOURCE:
+        # compute_coverage()
+        compute_coverage_jacoco(app_class_files_path)
+    else:
+        compute_coverage_ella()
+
+def pull_coverage_files(restore_count, app_package_name, app_class_files_path, avd_serial):
+    if RunParameters.OPEN_SOURCE:
+        # get_emma_coverage(restore_count)
+        get_jacoco_coverage(restore_count, app_package_name, app_class_files_path, avd_serial)
+    else:
+        get_ella_coverage(restore_count)
+
 def record_coverage():
     start_time = time.time()
     file_path='../../output/coverage_time.csv'
@@ -92,10 +142,13 @@ def record_coverage():
     while True:
         with open(file_path, 'a') as coverage_file:
             t = time.time() - start_time
-            
-            compute_coverage()
-            coverage = read_coverage()
-            
+
+            # compute_coverage()
+            # coverage = read_coverage()
+            # TODO, record_coverage() is not used in the project, so it is okay for now without giving proper parameters.
+            compute_coverage_jacoco()
+            coverage = read_coverage_jacoco()
+
             line = str(round(t,1)) + "," + str(coverage) + "\n"
             coverage_file.writelines(line)
             coverage_file.flush()
@@ -114,3 +167,4 @@ def record_coverage():
     compute_coverage_ella()
     tp=read_coverage_ella()
     print str(tp)
+