From 7a383342de6687a09b46151c1f3cf0d44810995a Mon Sep 17 00:00:00 2001
From: microsvuln <55649192+Microsvuln@users.noreply.github.com>
Date: Sat, 3 Apr 2021 02:07:52 +0400
Subject: rename python file

rename python file
---
 utils/autodict_ql/autodict-ql.py | 188 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 188 insertions(+)
 create mode 100644 utils/autodict_ql/autodict-ql.py

(limited to 'utils/autodict_ql/autodict-ql.py')

diff --git a/utils/autodict_ql/autodict-ql.py b/utils/autodict_ql/autodict-ql.py
new file mode 100644
index 00000000..69d11f48
--- /dev/null
+++ b/utils/autodict_ql/autodict-ql.py
@@ -0,0 +1,188 @@
+#!/usr/bin/env python3
+import os
+import string
+import binascii 
+import codecs
+import errno
+import struct
+import argparse
+import shutil
+import subprocess
+
+from binascii import unhexlify
+
+def ensure_dir(dir):
+    try:
+        os.makedirs(dir)
+    except OSError as e:
+        if e.errno != errno.EEXIST:
+            raise
+
+def parse_args():
+    parser = argparse.ArgumentParser(description=(
+        "Helper - Specify input file analysis and output folder to save corpus for strings in the overall project ---------------------------------------------------------------------------  Example usage : python2 thisfile.py outdir str.txt"    ))
+    
+    #parser.add_argument("tokenpath",
+        #help="Destination directory for tokens")
+    parser.add_argument("cur",
+            help = "Current Path")
+    parser.add_argument("db",
+            help = "CodeQL database Path")
+    parser.add_argument("tokenpath",
+            help="Destination directory for tokens")
+
+    return parser.parse_args()
+
+def static_analysis(file,file2,cur,db) :
+    with open(cur+"/"+file, "w") as f:
+        print(cur+"/"+file)
+        stream = os.popen("codeql query run " + cur +"/"+ file2 +  " -d " + db )
+        output = stream.read()
+        f.write(output)
+        f.close()
+
+def copy_tokens(cur, tokenpath) :
+    subprocess.call(["cp " + cur  + "/" + "arrays-lits/*" + " " + cur + "/" + tokenpath + "/."] ,shell=True)
+    subprocess.call(["cp " + cur  + "/" + "strstr-strs/*" + " " + cur + "/" + tokenpath + "/."] ,shell=True)
+    subprocess.call(["cp " + cur  + "/" + "strcmp-strs/*" + " " + cur + "/" + tokenpath + "/."] ,shell=True)
+    subprocess.call(["cp " + cur  + "/" + "strncmp-strs/*" + " " + cur + "/" + tokenpath + "/."] ,shell=True)
+    subprocess.call(["cp " + cur  + "/" + "local-strs/*" + " " + cur + "/" + tokenpath + "/."] ,shell=True)
+    subprocess.call(["cp " + cur  + "/" + "memcmp-strs/*" + " " + cur + "/" + tokenpath + "/."] ,shell=True)
+    subprocess.call(["cp " + cur  + "/" + "global-strs/*" + " " + cur + "/" + tokenpath + "/."] ,shell=True)
+    subprocess.call(["cp " + cur  + "/" + "lits/*" + " " + cur + "/" + tokenpath + "/."] ,shell=True)
+    subprocess.call(["cp " + cur  + "/" + "arrays-lits/*" + " " + cur + "/" + tokenpath + "/."] ,shell=True)
+    subprocess.call(["cp " + cur  + "/" + "arrays-strs/*" + " " + cur + "/" + tokenpath + "/."] ,shell=True)
+    subprocess.call(["cp " + cur  + "/" + "strtool-strs/*" + " " + cur + "/" + tokenpath + "/."] ,shell=True)
+    #strtool-strs
+
+
+def codeql_analysis(cur, db) :
+    static_analysis("litout.out","litool.ql", cur, db)
+    static_analysis("strcmp-strings.out","strcmp-str.ql", cur, db)
+    static_analysis("strncmp-strings.out","strncmp-str.ql", cur, db)
+    static_analysis("strstr-strings.out","strstr-str.ql", cur, db)
+    static_analysis("memcmp-strings.out","memcmp-str.ql", cur, db)
+    static_analysis("global-values-strings.out","globals-values.ql", cur, db)
+    static_analysis("local-strings.out","locals-strs.ql", cur, db)
+    static_analysis("strtool-strings.out","strtool.ql", cur, db)
+    static_analysis("arrays.out","array-literals.ql", cur, db)
+    start_aflql(0,cur)
+    #command1 = [
+    #       'codeql','query', 'run',
+    #       cur + '/litool.ql',
+    #       '-d',
+    #       db, '>','fff.txt'
+    #    ]
+    #with open("litool2.log", "w") as f:
+    #    stream = os.popen("codeql query run litool.ql -d " + db )
+    #    output = stream.read()
+    #    f.write(output)
+    #    f.close()
+    #worker1 = subprocess.Popen(command1)
+    #print(worker1.communicate())
+
+
+def start_aflql(tokenpath, cur):
+    command = [
+           'python3',
+           cur + '/litan.py',
+           cur+'/lits/',
+           cur+'/litout.out'
+        ]
+    worker1 = subprocess.Popen(command)
+    print(worker1.communicate())
+    
+    command1 = [
+           'python3',
+           cur + '/strcmp-strings.py',
+           cur + '/strcmp-strs/',
+           cur + '/strcmp-strings.out'
+        ]
+    worker2 = subprocess.Popen(command1)
+    print(worker2.communicate())
+
+    command2 = [
+           'python3',
+           cur + '/strncmp-strings.py',
+           cur + '/strncmp-strs/',
+           cur + '/strncmp-strings.out'
+        ]
+    worker3 = subprocess.Popen(command2)
+    print(worker3.communicate())
+
+    command3 = [
+           'python3',
+           cur + '/array-lits.py',
+           cur + '/arrays-lits/',
+           cur + '/arrays.out'
+        ]
+    worker4 = subprocess.Popen(command3)
+    print(worker4.communicate())
+
+    command4 = [
+           'python3',
+           cur + '/array-strings.py',
+           cur + '/arrays-strs/',
+           cur + '/arrays.out'
+        ]
+    worker5 = subprocess.Popen(command4)
+    print(worker5.communicate())
+
+
+    command5 = [
+           'python3',
+           cur + '/memcmp-strings.py',
+           cur + '/memcmp-strs/',
+           cur + '/memcmp-strings.out'
+        ]
+    worker6 = subprocess.Popen(command5)
+    print(worker6.communicate())
+
+    command6 = [
+           'python3',
+           cur + '/globals-strings.py',
+           cur + '/global-strs/',
+           cur + '/global-values-strings.out'
+        ]
+    worker7 = subprocess.Popen(command6)
+    print(worker7.communicate())
+
+    command7 = [
+           'python3',
+           cur + '/strstr-strings.py',
+           cur + '/strstr-strs/',
+           cur + '/strstr-strings.out'
+        ]
+    worker8 = subprocess.Popen(command7)
+    print(worker8.communicate())
+
+
+    #strtool-strings.out
+
+    command8 = [
+           'python3',
+           cur + '/stan-strings.py',
+           cur + '/strtool-strs/',
+           cur + '/strtool-strings.out'
+        ]
+    worker9 = subprocess.Popen(command8)
+    print(worker9.communicate())
+
+    command9 = [
+           'python3',
+           cur + '/local-strings.py',
+           cur + '/local-strs/',
+           cur + '/local-strings.out'
+        ]
+    worker10 = subprocess.Popen(command9)
+    print(worker10.communicate())
+
+def main():
+    args = parse_args()    
+    ensure_dir(args.tokenpath)
+    #copy_tokens(args.cur, args.tokenpath)
+    codeql_analysis(args.cur, args.db)
+    copy_tokens(args.cur, args.tokenpath)
+    #start_aflql(args.tokenpath, args.cur)
+if __name__ == '__main__':
+    main()
\ No newline at end of file
-- 
cgit 1.4.1


From 4291c3db5dca5082aed123f3a353f8af4a0f4785 Mon Sep 17 00:00:00 2001
From: microsvuln <55649192+Microsvuln@users.noreply.github.com>
Date: Sat, 3 Apr 2021 14:04:06 +0400
Subject: finalize 1

commit final things
---
 utils/autodict_ql/autodict-ql.py | 91 ++++++++--------------------------------
 utils/autodict_ql/readme.md      |  6 ++-
 2 files changed, 22 insertions(+), 75 deletions(-)

(limited to 'utils/autodict_ql/autodict-ql.py')

diff --git a/utils/autodict_ql/autodict-ql.py b/utils/autodict_ql/autodict-ql.py
index 69d11f48..ddc95435 100644
--- a/utils/autodict_ql/autodict-ql.py
+++ b/utils/autodict_ql/autodict-ql.py
@@ -1,4 +1,14 @@
 #!/usr/bin/env python3
+# AutoDict-QL - Optimal Token Generation for Fuzzing
+# Part of AFL++ Project
+# Developed and Maintained by Arash Ale Ebrahim (@Microsvuln)
+# Usage : python3 autodict-ql.py [CURRECT_DIR] [CODEQL_DATABASE_PATH] [TOKEN_PATH]
+# CURRENT_DIR = full of your current Dir
+# CODEQL_DATABASE_PATH = Full path to your CodeQL database
+# TOKEN_PATH = Folder name of the newly generated tokens
+# Example : python3 autodict-ql.py /home/user/libxml/automate /home/user/libxml/libxml-db tokens
+# Just pass the tokens folder to the -x flag of your fuzzer
+
 import os
 import string
 import binascii 
@@ -42,47 +52,25 @@ def static_analysis(file,file2,cur,db) :
         f.close()
 
 def copy_tokens(cur, tokenpath) :
-    subprocess.call(["cp " + cur  + "/" + "arrays-lits/*" + " " + cur + "/" + tokenpath + "/."] ,shell=True)
-    subprocess.call(["cp " + cur  + "/" + "strstr-strs/*" + " " + cur + "/" + tokenpath + "/."] ,shell=True)
     subprocess.call(["cp " + cur  + "/" + "strcmp-strs/*" + " " + cur + "/" + tokenpath + "/."] ,shell=True)
     subprocess.call(["cp " + cur  + "/" + "strncmp-strs/*" + " " + cur + "/" + tokenpath + "/."] ,shell=True)
-    subprocess.call(["cp " + cur  + "/" + "local-strs/*" + " " + cur + "/" + tokenpath + "/."] ,shell=True)
     subprocess.call(["cp " + cur  + "/" + "memcmp-strs/*" + " " + cur + "/" + tokenpath + "/."] ,shell=True)
-    subprocess.call(["cp " + cur  + "/" + "global-strs/*" + " " + cur + "/" + tokenpath + "/."] ,shell=True)
     subprocess.call(["cp " + cur  + "/" + "lits/*" + " " + cur + "/" + tokenpath + "/."] ,shell=True)
-    subprocess.call(["cp " + cur  + "/" + "arrays-lits/*" + " " + cur + "/" + tokenpath + "/."] ,shell=True)
-    subprocess.call(["cp " + cur  + "/" + "arrays-strs/*" + " " + cur + "/" + tokenpath + "/."] ,shell=True)
     subprocess.call(["cp " + cur  + "/" + "strtool-strs/*" + " " + cur + "/" + tokenpath + "/."] ,shell=True)
-    #strtool-strs
+
 
 
 def codeql_analysis(cur, db) :
     static_analysis("litout.out","litool.ql", cur, db)
     static_analysis("strcmp-strings.out","strcmp-str.ql", cur, db)
     static_analysis("strncmp-strings.out","strncmp-str.ql", cur, db)
-    static_analysis("strstr-strings.out","strstr-str.ql", cur, db)
     static_analysis("memcmp-strings.out","memcmp-str.ql", cur, db)
-    static_analysis("global-values-strings.out","globals-values.ql", cur, db)
-    static_analysis("local-strings.out","locals-strs.ql", cur, db)
     static_analysis("strtool-strings.out","strtool.ql", cur, db)
-    static_analysis("arrays.out","array-literals.ql", cur, db)
-    start_aflql(0,cur)
-    #command1 = [
-    #       'codeql','query', 'run',
-    #       cur + '/litool.ql',
-    #       '-d',
-    #       db, '>','fff.txt'
-    #    ]
-    #with open("litool2.log", "w") as f:
-    #    stream = os.popen("codeql query run litool.ql -d " + db )
-    #    output = stream.read()
-    #    f.write(output)
-    #    f.close()
-    #worker1 = subprocess.Popen(command1)
-    #print(worker1.communicate())
-
-
-def start_aflql(tokenpath, cur):
+    start_autodict(0,cur)
+
+
+
+def start_autodict(tokenpath, cur):
     command = [
            'python3',
            cur + '/litan.py',
@@ -110,23 +98,6 @@ def start_aflql(tokenpath, cur):
     worker3 = subprocess.Popen(command2)
     print(worker3.communicate())
 
-    command3 = [
-           'python3',
-           cur + '/array-lits.py',
-           cur + '/arrays-lits/',
-           cur + '/arrays.out'
-        ]
-    worker4 = subprocess.Popen(command3)
-    print(worker4.communicate())
-
-    command4 = [
-           'python3',
-           cur + '/array-strings.py',
-           cur + '/arrays-strs/',
-           cur + '/arrays.out'
-        ]
-    worker5 = subprocess.Popen(command4)
-    print(worker5.communicate())
 
 
     command5 = [
@@ -138,27 +109,8 @@ def start_aflql(tokenpath, cur):
     worker6 = subprocess.Popen(command5)
     print(worker6.communicate())
 
-    command6 = [
-           'python3',
-           cur + '/globals-strings.py',
-           cur + '/global-strs/',
-           cur + '/global-values-strings.out'
-        ]
-    worker7 = subprocess.Popen(command6)
-    print(worker7.communicate())
-
-    command7 = [
-           'python3',
-           cur + '/strstr-strings.py',
-           cur + '/strstr-strs/',
-           cur + '/strstr-strings.out'
-        ]
-    worker8 = subprocess.Popen(command7)
-    print(worker8.communicate())
 
 
-    #strtool-strings.out
-
     command8 = [
            'python3',
            cur + '/stan-strings.py',
@@ -168,14 +120,7 @@ def start_aflql(tokenpath, cur):
     worker9 = subprocess.Popen(command8)
     print(worker9.communicate())
 
-    command9 = [
-           'python3',
-           cur + '/local-strings.py',
-           cur + '/local-strs/',
-           cur + '/local-strings.out'
-        ]
-    worker10 = subprocess.Popen(command9)
-    print(worker10.communicate())
+
 
 def main():
     args = parse_args()    
@@ -183,6 +128,6 @@ def main():
     #copy_tokens(args.cur, args.tokenpath)
     codeql_analysis(args.cur, args.db)
     copy_tokens(args.cur, args.tokenpath)
-    #start_aflql(args.tokenpath, args.cur)
+    #start_autodict(args.tokenpath, args.cur)
 if __name__ == '__main__':
     main()
\ No newline at end of file
diff --git a/utils/autodict_ql/readme.md b/utils/autodict_ql/readme.md
index 3e4655c8..f8d23098 100644
--- a/utils/autodict_ql/readme.md
+++ b/utils/autodict_ql/readme.md
@@ -67,7 +67,7 @@ Commands:
   github    Commands useful for interacting with the GitHub API through CodeQL.
 ```
 
-2. Compiler your project with CodeQL: For using the Autodict-QL plugin, you need to compile the source of the target you want to fuzz with CodeQL. This is not something hard .
+2. Compile your project with CodeQL: For using the Autodict-QL plugin, you need to compile the source of the target you want to fuzz with CodeQL. This is not something hard .
 	- First you need to create a CodeQL database of the project codebase, suppose we want to compile the libxml with codeql. go to libxml and issue the following commands:
 		- `./configure --disable-shared`
 		- `codeql create database libxml-db --language=cpp --command=make`
@@ -87,10 +87,12 @@ Commands:
 Core developer of the AFL++ project Marc Heuse also developed a similar tool named `dict2file` which is a LLVM pass which can automatically extracts useful tokens, in addition with LTO instrumentation mode, this dict2file is automtically generates token extraction. `Autodict-QL` plugin gives you scripting capability and you can do whatever you want to extract from the Codebase and it's up to you. in addition it's independent from LLVM system.
 On the other hand, you can also use Google dictionaries which have been made public in May 2020, but the problem of using Google dictionaries is that they are limited to specific file format and speicifications. for example, for testing binutils and ELF file format or AVI in FFMPEG, there are no prebuilt dictionary, so it is highly recommended to use `Autodict-QL` or `Dict2File` features to automatically generating dictionaries based on the target.
 
-I've personally prefer to use `Autodict-QL` or `dict2file` rather than Google dictionaries or any other manully generated dictionaries as `Autodict-QL` is working based on the target.
+I've personally prefer to use `Autodict-QL` or `dict2file` rather than Google dictionaries or any other manully generated dictionaries as `Autodict-QL` and `dict2file` is working based on the target.
 In overall, fuzzing with dictionaries and well-generated tokens will give better results.
 
 There are 2 important points to remember :
 
 - If you combine `Autodict-QL` with AFL++ cmplog, you will get much better code coverage and hence better chance to discover new bugs.
 - Do not remember to set the `AFL_MAX_DET_EXTRAS` to the number of generated dictionaries, if you forget to set this environment variable, then AFL++ use just 200 tokens and use the rest of them probablistically. So this will guarantees that your tokens will be used by AFL++.
+
+Thanks are going to Marc Heuse, the AFL++ main developer, Antonio Morales and Stefan Nagy
\ No newline at end of file
-- 
cgit 1.4.1


From 70e975704465672f49273da9f4a8f7e56f745e20 Mon Sep 17 00:00:00 2001
From: microsvuln <55649192+Microsvuln@users.noreply.github.com>
Date: Sat, 3 Apr 2021 15:47:22 +0400
Subject: new commit - change strings

new commit - change strings
---
 utils/autodict_ql/autodict-ql.py     |  1 +
 utils/autodict_ql/build-codeql.sh    |  4 ++--
 utils/autodict_ql/memcmp-strings.py  |  3 +--
 utils/autodict_ql/readme.md          | 11 ++++++++---
 utils/autodict_ql/stan-strings.py    |  3 +--
 utils/autodict_ql/strcmp-strings.py  |  3 +--
 utils/autodict_ql/strncmp-strings.py |  3 +--
 7 files changed, 15 insertions(+), 13 deletions(-)

(limited to 'utils/autodict_ql/autodict-ql.py')

diff --git a/utils/autodict_ql/autodict-ql.py b/utils/autodict_ql/autodict-ql.py
index ddc95435..7bba57fc 100644
--- a/utils/autodict_ql/autodict-ql.py
+++ b/utils/autodict_ql/autodict-ql.py
@@ -57,6 +57,7 @@ def copy_tokens(cur, tokenpath) :
     subprocess.call(["cp " + cur  + "/" + "memcmp-strs/*" + " " + cur + "/" + tokenpath + "/."] ,shell=True)
     subprocess.call(["cp " + cur  + "/" + "lits/*" + " " + cur + "/" + tokenpath + "/."] ,shell=True)
     subprocess.call(["cp " + cur  + "/" + "strtool-strs/*" + " " + cur + "/" + tokenpath + "/."] ,shell=True)
+    subprocess.call(["find "+tokenpath+" -size 0 -delete"],shell=True)
 
 
 
diff --git a/utils/autodict_ql/build-codeql.sh b/utils/autodict_ql/build-codeql.sh
index ccff932e..450207f6 100644
--- a/utils/autodict_ql/build-codeql.sh
+++ b/utils/autodict_ql/build-codeql.sh
@@ -3,7 +3,6 @@ if [ -d "codeql-home" ]; then
     echo "Exist !"
     exit 1
 fi
-sudo apt install build-essential libtool-bin python3-dev automake git vim wget -y
 mkdir codeql-home
 cd codeql-home
 git clone https://github.com/github/codeql.git codeql-repo
@@ -12,6 +11,7 @@ wget https://github.com/github/codeql-cli-binaries/releases/download/v2.4.6/code
 unzip codeql-linux64.zip 
 mv codeql codeql-cli
 export "PATH=~/codeql-home/codeql-cli/:$PATH"
+echo "export PATH=~/codeql-home/codeql-cli/:$PATH" >> ~/.bashrc
 codeql resolve languages
 codeql resolve qlpacks
-echo "export PATH=~/codeql-home/codeql-cli/:$PATH" >> ~/.bashrc
\ No newline at end of file
+codeql
\ No newline at end of file
diff --git a/utils/autodict_ql/memcmp-strings.py b/utils/autodict_ql/memcmp-strings.py
index fb892aff..2814da5b 100644
--- a/utils/autodict_ql/memcmp-strings.py
+++ b/utils/autodict_ql/memcmp-strings.py
@@ -46,9 +46,8 @@ def do_string_analysis(corpdir, infile1):
                 str11 = str11.replace("\n","")
                 str11 = str11.lstrip()
                 str11 = str11.rstrip()
-                print("all strings : %s" % str11)
                 str11 = str(str11)
-                if ((" " in str11 ) or (")" in str11) or ("(" in str11)):                    
+                if ((" " in str11 ) or (")" in str11) or ("(" in str11) or ("<" in str11) or (">" in str11)) :
                     print("Space / Paranthesis String : %s" % str11)
                 else :
                     with open(corpdir+'/memcmp-str{0}'.format(n), 'w') as file:                    
diff --git a/utils/autodict_ql/readme.md b/utils/autodict_ql/readme.md
index 9e6a7292..ccc9b0e3 100644
--- a/utils/autodict_ql/readme.md
+++ b/utils/autodict_ql/readme.md
@@ -31,13 +31,18 @@ You can write other CodeQL scripts to extract possible effective tokens if you t
 
 ## Usage
 
+Before proceed to installation make sure that you have the following packages by installing them :
+```shell
+sudo apt install build-essential libtool-bin python3-dev python3 automake git vim wget -y
+```
 The usage of Autodict-QL is pretty easy. But let's describe it as :
 
-1. First of all, you need to have CodeQL installed on the system. we make this possible with `build-codeql.sh` bash script. This script will install CodeQL completety and will set the required environment variables for your system, so :
-
+1. First of all, you need to have CodeQL installed on the system. we make this possible with `build-codeql.sh` bash script. This script will install CodeQL completety and will set the required environment variables for your system.
+Do the following :
 ```shell
 # chmod +x codeql-build.sh
-# sudo ./codeql-build.sh
+# ./codeql-build.sh
+# source ~/.bashrc
 # codeql 
 ```
 Then you should get :
diff --git a/utils/autodict_ql/stan-strings.py b/utils/autodict_ql/stan-strings.py
index e9f6f0d0..5a863f80 100644
--- a/utils/autodict_ql/stan-strings.py
+++ b/utils/autodict_ql/stan-strings.py
@@ -46,9 +46,8 @@ def do_string_analysis(corpdir, infile1):
                 str11 = str11.replace("\n","")
                 str11 = str11.lstrip()
                 str11 = str11.rstrip()
-                print("all strings : %s" % str11)
                 str11 = str(str11)
-                if ((" " in str11 ) or (")" in str11) or ("(" in str11)) or ("<" in str11) or (">" in str11) :
+                if ((" " in str11 ) or (")" in str11) or ("(" in str11) or ("<" in str11) or (">" in str11)) :
                     print("Space / Paranthesis String : %s" % str11)
                 else :
                     with open(corpdir+'/seed-str{0}'.format(n), 'w') as file:                    
diff --git a/utils/autodict_ql/strcmp-strings.py b/utils/autodict_ql/strcmp-strings.py
index a1b7e27c..1852b947 100644
--- a/utils/autodict_ql/strcmp-strings.py
+++ b/utils/autodict_ql/strcmp-strings.py
@@ -46,9 +46,8 @@ def do_string_analysis(corpdir, infile1):
                 str11 = str11.replace("\n","")
                 str11 = str11.lstrip()
                 str11 = str11.rstrip()
-                print("all strings : %s" % str11)
                 str11 = str(str11)
-                if ((" " in str11 ) or (")" in str11) or ("(" in str11)):                    
+                if ((" " in str11 ) or (")" in str11) or ("(" in str11) or ("<" in str11) or (">" in str11)) :
                     print("Space / Paranthesis String : %s" % str11)
                 else :
                     with open(corpdir+'/strcmp-str{0}'.format(n), 'w') as file:                    
diff --git a/utils/autodict_ql/strncmp-strings.py b/utils/autodict_ql/strncmp-strings.py
index 2652f66e..f00fa3da 100644
--- a/utils/autodict_ql/strncmp-strings.py
+++ b/utils/autodict_ql/strncmp-strings.py
@@ -46,9 +46,8 @@ def do_string_analysis(corpdir, infile1):
                 str11 = str11.replace("\n","")
                 str11 = str11.lstrip()
                 str11 = str11.rstrip()
-                print("all strings : %s" % str11)
                 str11 = str(str11)
-                if ((" " in str11 ) or (")" in str11) or ("(" in str11)):                    
+                if ((" " in str11 ) or (")" in str11) or ("(" in str11) or ("<" in str11) or (">" in str11)) :
                     print("Space / Paranthesis String : %s" % str11)
                 else :
                     with open(corpdir+'/strncmp-str{0}'.format(n), 'w') as file:                    
-- 
cgit 1.4.1


From 050f331c54a7af2fdb2eb1ca33e9dacd9257dbb0 Mon Sep 17 00:00:00 2001
From: microsvuln <55649192+Microsvuln@users.noreply.github.com>
Date: Sat, 3 Apr 2021 16:04:14 +0400
Subject: remove unessential things

remove unessential things from scripts
---
 utils/autodict_ql/autodict-ql.py     | 10 +++++-----
 utils/autodict_ql/memcmp-strings.py  |  2 +-
 utils/autodict_ql/stan-strings.py    |  2 +-
 utils/autodict_ql/strcmp-strings.py  |  2 +-
 utils/autodict_ql/strncmp-strings.py |  2 +-
 5 files changed, 9 insertions(+), 9 deletions(-)

(limited to 'utils/autodict_ql/autodict-ql.py')

diff --git a/utils/autodict_ql/autodict-ql.py b/utils/autodict_ql/autodict-ql.py
index 7bba57fc..b51fbb90 100644
--- a/utils/autodict_ql/autodict-ql.py
+++ b/utils/autodict_ql/autodict-ql.py
@@ -52,11 +52,11 @@ def static_analysis(file,file2,cur,db) :
         f.close()
 
 def copy_tokens(cur, tokenpath) :
-    subprocess.call(["cp " + cur  + "/" + "strcmp-strs/*" + " " + cur + "/" + tokenpath + "/."] ,shell=True)
-    subprocess.call(["cp " + cur  + "/" + "strncmp-strs/*" + " " + cur + "/" + tokenpath + "/."] ,shell=True)
-    subprocess.call(["cp " + cur  + "/" + "memcmp-strs/*" + " " + cur + "/" + tokenpath + "/."] ,shell=True)
-    subprocess.call(["cp " + cur  + "/" + "lits/*" + " " + cur + "/" + tokenpath + "/."] ,shell=True)
-    subprocess.call(["cp " + cur  + "/" + "strtool-strs/*" + " " + cur + "/" + tokenpath + "/."] ,shell=True)
+    subprocess.call(["mv " + cur  + "/" + "strcmp-strs/*" + " " + cur + "/" + tokenpath + "/."] ,shell=True)
+    subprocess.call(["mv " + cur  + "/" + "strncmp-strs/*" + " " + cur + "/" + tokenpath + "/."] ,shell=True)
+    subprocess.call(["mv " + cur  + "/" + "memcmp-strs/*" + " " + cur + "/" + tokenpath + "/."] ,shell=True)
+    subprocess.call(["mv " + cur  + "/" + "lits/*" + " " + cur + "/" + tokenpath + "/."] ,shell=True)
+    subprocess.call(["mv " + cur  + "/" + "strtool-strs/*" + " " + cur + "/" + tokenpath + "/."] ,shell=True)
     subprocess.call(["find "+tokenpath+" -size 0 -delete"],shell=True)
 
 
diff --git a/utils/autodict_ql/memcmp-strings.py b/utils/autodict_ql/memcmp-strings.py
index 2814da5b..d1047caa 100644
--- a/utils/autodict_ql/memcmp-strings.py
+++ b/utils/autodict_ql/memcmp-strings.py
@@ -40,7 +40,7 @@ def do_string_analysis(corpdir, infile1):
         for i, num1 in enumerate(lines):
             if i != 0:
                 new_lst1.append(num1)
-                print("num : %s" % num1)
+                #print("num : %s" % num1)
                 str11 = str(num1)
                 str11 = str11.replace("|","")
                 str11 = str11.replace("\n","")
diff --git a/utils/autodict_ql/stan-strings.py b/utils/autodict_ql/stan-strings.py
index 5a863f80..65d08c97 100644
--- a/utils/autodict_ql/stan-strings.py
+++ b/utils/autodict_ql/stan-strings.py
@@ -40,7 +40,7 @@ def do_string_analysis(corpdir, infile1):
         for i, num1 in enumerate(lines):
             if i != 0:
                 new_lst1.append(num1)
-                print("num : %s" % num1)
+                #print("num : %s" % num1)
                 str11 = str(num1)
                 str11 = str11.replace("|","")
                 str11 = str11.replace("\n","")
diff --git a/utils/autodict_ql/strcmp-strings.py b/utils/autodict_ql/strcmp-strings.py
index 1852b947..88128dbb 100644
--- a/utils/autodict_ql/strcmp-strings.py
+++ b/utils/autodict_ql/strcmp-strings.py
@@ -40,7 +40,7 @@ def do_string_analysis(corpdir, infile1):
         for i, num1 in enumerate(lines):
             if i != 0:
                 new_lst1.append(num1)
-                print("num : %s" % num1)
+                #print("num : %s" % num1)
                 str11 = str(num1)
                 str11 = str11.replace("|","")
                 str11 = str11.replace("\n","")
diff --git a/utils/autodict_ql/strncmp-strings.py b/utils/autodict_ql/strncmp-strings.py
index f00fa3da..0ad0e697 100644
--- a/utils/autodict_ql/strncmp-strings.py
+++ b/utils/autodict_ql/strncmp-strings.py
@@ -40,7 +40,7 @@ def do_string_analysis(corpdir, infile1):
         for i, num1 in enumerate(lines):
             if i != 0:
                 new_lst1.append(num1)
-                print("num : %s" % num1)
+                #print("num : %s" % num1)
                 str11 = str(num1)
                 str11 = str11.replace("|","")
                 str11 = str11.replace("\n","")
-- 
cgit 1.4.1


From 05c13588d7f6a0c8e34623eeed0b2920737ba377 Mon Sep 17 00:00:00 2001
From: microsvuln <55649192+Microsvuln@users.noreply.github.com>
Date: Sat, 3 Apr 2021 16:22:51 +0400
Subject: remove dirs

remove dirs
---
 utils/autodict_ql/autodict-ql.py | 2 ++
 utils/autodict_ql/readme.md      | 3 +--
 2 files changed, 3 insertions(+), 2 deletions(-)

(limited to 'utils/autodict_ql/autodict-ql.py')

diff --git a/utils/autodict_ql/autodict-ql.py b/utils/autodict_ql/autodict-ql.py
index b51fbb90..0fe7eabf 100644
--- a/utils/autodict_ql/autodict-ql.py
+++ b/utils/autodict_ql/autodict-ql.py
@@ -57,6 +57,8 @@ def copy_tokens(cur, tokenpath) :
     subprocess.call(["mv " + cur  + "/" + "memcmp-strs/*" + " " + cur + "/" + tokenpath + "/."] ,shell=True)
     subprocess.call(["mv " + cur  + "/" + "lits/*" + " " + cur + "/" + tokenpath + "/."] ,shell=True)
     subprocess.call(["mv " + cur  + "/" + "strtool-strs/*" + " " + cur + "/" + tokenpath + "/."] ,shell=True)
+    subprocess.call(["rm -rf strcmp-strs memcmp-strs strncmp-strs lits strtool-strs"],shell=True)
+    subprocess.call(["rm *.out"],shell=True)
     subprocess.call(["find "+tokenpath+" -size 0 -delete"],shell=True)
 
 
diff --git a/utils/autodict_ql/readme.md b/utils/autodict_ql/readme.md
index ccc9b0e3..16a2a20b 100644
--- a/utils/autodict_ql/readme.md
+++ b/utils/autodict_ql/readme.md
@@ -93,7 +93,7 @@ Commands:
 Core developer of the AFL++ project Marc Heuse also developed a similar tool named `dict2file` which is a LLVM pass which can automatically extracts useful tokens, in addition with LTO instrumentation mode, this dict2file is automtically generates token extraction. `Autodict-QL` plugin gives you scripting capability and you can do whatever you want to extract from the Codebase and it's up to you. in addition it's independent from LLVM system.
 On the other hand, you can also use Google dictionaries which have been made public in May 2020, but the problem of using Google dictionaries is that they are limited to specific file format and speicifications. for example, for testing binutils and ELF file format or AVI in FFMPEG, there are no prebuilt dictionary, so it is highly recommended to use `Autodict-QL` or `Dict2File` features to automatically generating dictionaries based on the target.
 
-I've personally prefer to use `Autodict-QL` or `dict2file` rather than Google dictionaries or any other manully generated dictionaries as `Autodict-QL` and `dict2file` is working based on the target.
+I've personally prefer to use `Autodict-QL` or `dict2file` rather than Google dictionaries or any other manully generated dictionaries as `Autodict-QL` and `dict2file` are working based on the target.
 In overall, fuzzing with dictionaries and well-generated tokens will give better results.
 
 There are 2 important points to remember :
@@ -101,4 +101,3 @@ There are 2 important points to remember :
 - If you combine `Autodict-QL` with AFL++ cmplog, you will get much better code coverage and hence better chance to discover new bugs.
 - Do not remember to set the `AFL_MAX_DET_EXTRAS` to the number of generated dictionaries, if you forget to set this environment variable, then AFL++ use just 200 tokens and use the rest of them probablistically. So this will guarantees that your tokens will be used by AFL++.
 
-Thanks are going to Marc Heuse, the AFL++ main developer, Antonio Morales and Stefan Nagy
\ No newline at end of file
-- 
cgit 1.4.1


From c8e96e52536d47ee41967657202574d8e61562ee Mon Sep 17 00:00:00 2001
From: Dominik Maier <domenukk@gmail.com>
Date: Thu, 15 Apr 2021 23:56:58 +0200
Subject: autoformat with black

---
 frida_mode/test/testinstr.py                      |  49 ++++---
 unicorn_mode/helper_scripts/ida_context_loader.py |  84 +++++++-----
 utils/autodict_ql/autodict-ql.py                  | 154 ++++++++++++----------
 utils/autodict_ql/litan.py                        | 126 +++++++++++-------
 utils/autodict_ql/memcmp-strings.py               |  64 +++++----
 utils/autodict_ql/stan-strings.py                 |  64 +++++----
 utils/autodict_ql/strcmp-strings.py               |  64 +++++----
 utils/autodict_ql/strncmp-strings.py              |  64 +++++----
 8 files changed, 409 insertions(+), 260 deletions(-)

(limited to 'utils/autodict_ql/autodict-ql.py')

diff --git a/frida_mode/test/testinstr.py b/frida_mode/test/testinstr.py
index 8f5fe886..f648808b 100755
--- a/frida_mode/test/testinstr.py
+++ b/frida_mode/test/testinstr.py
@@ -1,32 +1,49 @@
-#!/usr/bin/python3
+#!/usr/bin/env python3
 import argparse
 from elftools.elf.elffile import ELFFile
 
+
 def process_file(file, section, base):
-    with open(file, 'rb') as f:
+    with open(file, "rb") as f:
         for sect in ELFFile(f).iter_sections():
-            if (sect.name == section):
-                start = base + sect.header['sh_offset']
-                end = start + sect.header['sh_size']
-                print ("0x%016x-0x%016x" % (start, end))
+            if sect.name == section:
+                start = base + sect.header["sh_offset"]
+                end = start + sect.header["sh_size"]
+                print("0x%016x-0x%016x" % (start, end))
                 return
 
-    print ("Section '%s' not found in '%s'" % (section, file))
+    print("Section '%s' not found in '%s'" % (section, file))
+
 
 def hex_value(x):
     return int(x, 16)
 
+
 def main():
-    parser = argparse.ArgumentParser(description='Process some integers.')
-    parser.add_argument('-f', '--file', dest='file', type=str,
-                    help='elf file name', required=True)
-    parser.add_argument('-s', '--section', dest='section', type=str,
-                    help='elf section name', required=True)
-    parser.add_argument('-b', '--base', dest='base', type=hex_value,
-                    help='elf base address', required=True)
+    parser = argparse.ArgumentParser(description="Process some integers.")
+    parser.add_argument(
+        "-f", "--file", dest="file", type=str, help="elf file name", required=True
+    )
+    parser.add_argument(
+        "-s",
+        "--section",
+        dest="section",
+        type=str,
+        help="elf section name",
+        required=True,
+    )
+    parser.add_argument(
+        "-b",
+        "--base",
+        dest="base",
+        type=hex_value,
+        help="elf base address",
+        required=True,
+    )
 
     args = parser.parse_args()
-    process_file (args.file, args.section, args.base)
+    process_file(args.file, args.section, args.base)
+
 
 if __name__ == "__main__":
-    main()
\ No newline at end of file
+    main()
diff --git a/unicorn_mode/helper_scripts/ida_context_loader.py b/unicorn_mode/helper_scripts/ida_context_loader.py
index 31d47a90..d7984c77 100644
--- a/unicorn_mode/helper_scripts/ida_context_loader.py
+++ b/unicorn_mode/helper_scripts/ida_context_loader.py
@@ -34,13 +34,11 @@ import ida_segment
 
 
 class ContextLoaderError(Exception):
-    """Base "catch all" exception for this script
-    """
+    """Base "catch all" exception for this script"""
 
 
 class ArchNotSupportedError(ContextLoaderError):
-    """Exception raised if the input file CPU architecture isn't supported fully
-    """
+    """Exception raised if the input file CPU architecture isn't supported fully"""
 
 
 def parse_mapping_index(filepath: str):
@@ -51,13 +49,16 @@ def parse_mapping_index(filepath: str):
     """
 
     if filepath is None:
-        raise ContextLoaderError('_index.json file was not selected')
+        raise ContextLoaderError("_index.json file was not selected")
 
     try:
-        with open(filepath, 'rb') as _file:
+        with open(filepath, "rb") as _file:
             return json.load(_file)
     except Exception as ex:
-        raise ContextLoaderError('Failed to parse json file {}'.format(filepath)) from ex
+        raise ContextLoaderError(
+            "Failed to parse json file {}".format(filepath)
+        ) from ex
+
 
 def get_input_name():
     """Get the name of the input file
@@ -68,19 +69,21 @@ def get_input_name():
     input_filepath = ida_nalt.get_input_file_path()
     return Path(input_filepath).name
 
+
 def write_segment_bytes(start: int, filepath: str):
-    """"Read data from context file and write it to the IDA segment
+    """ "Read data from context file and write it to the IDA segment
 
     :param start: Start address
     :param filepath: Path to context file
     """
 
-    with open(filepath, 'rb') as _file:
+    with open(filepath, "rb") as _file:
         data = _file.read()
 
     decompressed_data = zlib.decompress(data)
     ida_bytes.put_bytes(start, decompressed_data)
 
+
 def create_segment(context_dir: str, segment: dict, is_be: bool):
     """Create segment in IDA and map in the data from the file
 
@@ -90,23 +93,30 @@ def create_segment(context_dir: str, segment: dict, is_be: bool):
     """
 
     input_name = get_input_name()
-    if Path(segment['name']).name != input_name:
+    if Path(segment["name"]).name != input_name:
         ida_seg = idaapi.segment_t()
-        ida_seg.start_ea = segment['start']
-        ida_seg.end_ea = segment['end']
+        ida_seg.start_ea = segment["start"]
+        ida_seg.end_ea = segment["end"]
         ida_seg.bitness = 1 if is_be else 0
-        if segment['permissions']['r']:
+        if segment["permissions"]["r"]:
             ida_seg.perm |= ida_segment.SEGPERM_READ
-        if segment['permissions']['w']:
+        if segment["permissions"]["w"]:
             ida_seg.perm |= ida_segment.SEGPERM_WRITE
-        if segment['permissions']['x']:
+        if segment["permissions"]["x"]:
             ida_seg.perm |= ida_segment.SEGPERM_EXEC
-            idaapi.add_segm_ex(ida_seg, Path(segment['name']).name, 'CODE', idaapi.ADDSEG_OR_DIE)
+            idaapi.add_segm_ex(
+                ida_seg, Path(segment["name"]).name, "CODE", idaapi.ADDSEG_OR_DIE
+            )
         else:
-            idaapi.add_segm_ex(ida_seg, Path(segment['name']).name, 'DATA', idaapi.ADDSEG_OR_DIE)
+            idaapi.add_segm_ex(
+                ida_seg, Path(segment["name"]).name, "DATA", idaapi.ADDSEG_OR_DIE
+            )
+
+    if segment["content_file"]:
+        write_segment_bytes(
+            segment["start"], PurePath(context_dir, segment["content_file"])
+        )
 
-    if segment['content_file']:
-        write_segment_bytes(segment['start'], PurePath(context_dir, segment['content_file']))
 
 def create_segments(index: dict, context_dir: str):
     """Iterate segments in index JSON, create the segment in IDA, and map in the data from the file
@@ -117,9 +127,10 @@ def create_segments(index: dict, context_dir: str):
 
     info = idaapi.get_inf_structure()
     is_be = info.is_be()
-    for segment in index['segments']:
+    for segment in index["segments"]:
         create_segment(context_dir, segment, is_be)
 
+
 def rebase_program(index: dict):
     """Rebase the program to the offset specified in the context _index.json
 
@@ -128,20 +139,21 @@ def rebase_program(index: dict):
 
     input_name = get_input_name()
     new_base = None
-    for segment in index['segments']:
-        if not segment['name']:
+    for segment in index["segments"]:
+        if not segment["name"]:
             continue
 
-        segment_name = Path(segment['name']).name
+        segment_name = Path(segment["name"]).name
         if input_name == segment_name:
-            new_base = segment['start']
+            new_base = segment["start"]
             break
 
     if not new_base:
-        raise ContextLoaderError('Input file is not in _index.json')
+        raise ContextLoaderError("Input file is not in _index.json")
 
     current_base = idaapi.get_imagebase()
-    ida_segment.rebase_program(new_base-current_base, 8)
+    ida_segment.rebase_program(new_base - current_base, 8)
+
 
 def get_pc_by_arch(index: dict) -> int:
     """Queries the input file CPU architecture and attempts to lookup the address of the program
@@ -153,13 +165,14 @@ def get_pc_by_arch(index: dict) -> int:
 
     progctr = None
     info = idaapi.get_inf_structure()
-    if info.procname == 'metapc':
+    if info.procname == "metapc":
         if info.is_64bit():
-            progctr = index['regs']['rax']
+            progctr = index["regs"]["rax"]
         elif info.is_32bit():
-            progctr = index['regs']['eax']
+            progctr = index["regs"]["eax"]
     return progctr
 
+
 def write_reg_info(index: dict):
     """Write register info as line comment at instruction pointed to by the program counter and
     change focus to that location
@@ -167,17 +180,19 @@ def write_reg_info(index: dict):
     :param index: _index.json JSON data
     """
 
-    cmt = ''
-    for reg, val in index['regs'].items():
+    cmt = ""
+    for reg, val in index["regs"].items():
         cmt += f"{reg.ljust(6)} : {hex(val)}\n"
 
     progctr = get_pc_by_arch(index)
     if progctr is None:
         raise ArchNotSupportedError(
-            'Architecture not fully supported, skipping register status comment')
+            "Architecture not fully supported, skipping register status comment"
+        )
     ida_bytes.set_cmt(progctr, cmt, 0)
     ida_kernwin.jumpto(progctr)
 
+
 def main(filepath):
     """Main - parse _index.json input and map context files into the database
 
@@ -193,5 +208,6 @@ def main(filepath):
     except ContextLoaderError as ex:
         print(ex)
 
-if __name__ == '__main__':
-    main(ida_kernwin.ask_file(1, '*.json', 'Import file name'))
+
+if __name__ == "__main__":
+    main(ida_kernwin.ask_file(1, "*.json", "Import file name"))
diff --git a/utils/autodict_ql/autodict-ql.py b/utils/autodict_ql/autodict-ql.py
index 0fe7eabf..f64e3fae 100644
--- a/utils/autodict_ql/autodict-ql.py
+++ b/utils/autodict_ql/autodict-ql.py
@@ -11,7 +11,7 @@
 
 import os
 import string
-import binascii 
+import binascii
 import codecs
 import errno
 import struct
@@ -21,6 +21,7 @@ import subprocess
 
 from binascii import unhexlify
 
+
 def ensure_dir(dir):
     try:
         os.makedirs(dir)
@@ -28,109 +29,118 @@ def ensure_dir(dir):
         if e.errno != errno.EEXIST:
             raise
 
+
 def parse_args():
-    parser = argparse.ArgumentParser(description=(
-        "Helper - Specify input file analysis and output folder to save corpus for strings in the overall project ---------------------------------------------------------------------------  Example usage : python2 thisfile.py outdir str.txt"    ))
-    
-    #parser.add_argument("tokenpath",
-        #help="Destination directory for tokens")
-    parser.add_argument("cur",
-            help = "Current Path")
-    parser.add_argument("db",
-            help = "CodeQL database Path")
-    parser.add_argument("tokenpath",
-            help="Destination directory for tokens")
+    parser = argparse.ArgumentParser(
+        description=(
+            "Helper - Specify input file analysis and output folder to save corpus for strings in the overall project ---------------------------------------------------------------------------  Example usage : python2 thisfile.py outdir str.txt"
+        )
+    )
+
+    # parser.add_argument("tokenpath",
+    # help="Destination directory for tokens")
+    parser.add_argument("cur", help="Current Path")
+    parser.add_argument("db", help="CodeQL database Path")
+    parser.add_argument("tokenpath", help="Destination directory for tokens")
 
     return parser.parse_args()
 
-def static_analysis(file,file2,cur,db) :
-    with open(cur+"/"+file, "w") as f:
-        print(cur+"/"+file)
-        stream = os.popen("codeql query run " + cur +"/"+ file2 +  " -d " + db )
+
+def static_analysis(file, file2, cur, db):
+    with open(cur + "/" + file, "w") as f:
+        print(cur + "/" + file)
+        stream = os.popen("codeql query run " + cur + "/" + file2 + " -d " + db)
         output = stream.read()
         f.write(output)
         f.close()
 
-def copy_tokens(cur, tokenpath) :
-    subprocess.call(["mv " + cur  + "/" + "strcmp-strs/*" + " " + cur + "/" + tokenpath + "/."] ,shell=True)
-    subprocess.call(["mv " + cur  + "/" + "strncmp-strs/*" + " " + cur + "/" + tokenpath + "/."] ,shell=True)
-    subprocess.call(["mv " + cur  + "/" + "memcmp-strs/*" + " " + cur + "/" + tokenpath + "/."] ,shell=True)
-    subprocess.call(["mv " + cur  + "/" + "lits/*" + " " + cur + "/" + tokenpath + "/."] ,shell=True)
-    subprocess.call(["mv " + cur  + "/" + "strtool-strs/*" + " " + cur + "/" + tokenpath + "/."] ,shell=True)
-    subprocess.call(["rm -rf strcmp-strs memcmp-strs strncmp-strs lits strtool-strs"],shell=True)
-    subprocess.call(["rm *.out"],shell=True)
-    subprocess.call(["find "+tokenpath+" -size 0 -delete"],shell=True)
-
-
-
-def codeql_analysis(cur, db) :
-    static_analysis("litout.out","litool.ql", cur, db)
-    static_analysis("strcmp-strings.out","strcmp-str.ql", cur, db)
-    static_analysis("strncmp-strings.out","strncmp-str.ql", cur, db)
-    static_analysis("memcmp-strings.out","memcmp-str.ql", cur, db)
-    static_analysis("strtool-strings.out","strtool.ql", cur, db)
-    start_autodict(0,cur)
 
+def copy_tokens(cur, tokenpath):
+    subprocess.call(
+        ["mv " + cur + "/" + "strcmp-strs/*" + " " + cur + "/" + tokenpath + "/."],
+        shell=True,
+    )
+    subprocess.call(
+        ["mv " + cur + "/" + "strncmp-strs/*" + " " + cur + "/" + tokenpath + "/."],
+        shell=True,
+    )
+    subprocess.call(
+        ["mv " + cur + "/" + "memcmp-strs/*" + " " + cur + "/" + tokenpath + "/."],
+        shell=True,
+    )
+    subprocess.call(
+        ["mv " + cur + "/" + "lits/*" + " " + cur + "/" + tokenpath + "/."], shell=True
+    )
+    subprocess.call(
+        ["mv " + cur + "/" + "strtool-strs/*" + " " + cur + "/" + tokenpath + "/."],
+        shell=True,
+    )
+    subprocess.call(
+        ["rm -rf strcmp-strs memcmp-strs strncmp-strs lits strtool-strs"], shell=True
+    )
+    subprocess.call(["rm *.out"], shell=True)
+    subprocess.call(["find " + tokenpath + " -size 0 -delete"], shell=True)
+
+
+def codeql_analysis(cur, db):
+    static_analysis("litout.out", "litool.ql", cur, db)
+    static_analysis("strcmp-strings.out", "strcmp-str.ql", cur, db)
+    static_analysis("strncmp-strings.out", "strncmp-str.ql", cur, db)
+    static_analysis("memcmp-strings.out", "memcmp-str.ql", cur, db)
+    static_analysis("strtool-strings.out", "strtool.ql", cur, db)
+    start_autodict(0, cur)
 
 
 def start_autodict(tokenpath, cur):
-    command = [
-           'python3',
-           cur + '/litan.py',
-           cur+'/lits/',
-           cur+'/litout.out'
-        ]
+    command = ["python3", cur + "/litan.py", cur + "/lits/", cur + "/litout.out"]
     worker1 = subprocess.Popen(command)
     print(worker1.communicate())
-    
+
     command1 = [
-           'python3',
-           cur + '/strcmp-strings.py',
-           cur + '/strcmp-strs/',
-           cur + '/strcmp-strings.out'
-        ]
+        "python3",
+        cur + "/strcmp-strings.py",
+        cur + "/strcmp-strs/",
+        cur + "/strcmp-strings.out",
+    ]
     worker2 = subprocess.Popen(command1)
     print(worker2.communicate())
 
     command2 = [
-           'python3',
-           cur + '/strncmp-strings.py',
-           cur + '/strncmp-strs/',
-           cur + '/strncmp-strings.out'
-        ]
+        "python3",
+        cur + "/strncmp-strings.py",
+        cur + "/strncmp-strs/",
+        cur + "/strncmp-strings.out",
+    ]
     worker3 = subprocess.Popen(command2)
     print(worker3.communicate())
 
-
-
     command5 = [
-           'python3',
-           cur + '/memcmp-strings.py',
-           cur + '/memcmp-strs/',
-           cur + '/memcmp-strings.out'
-        ]
+        "python3",
+        cur + "/memcmp-strings.py",
+        cur + "/memcmp-strs/",
+        cur + "/memcmp-strings.out",
+    ]
     worker6 = subprocess.Popen(command5)
     print(worker6.communicate())
 
-
-
     command8 = [
-           'python3',
-           cur + '/stan-strings.py',
-           cur + '/strtool-strs/',
-           cur + '/strtool-strings.out'
-        ]
+        "python3",
+        cur + "/stan-strings.py",
+        cur + "/strtool-strs/",
+        cur + "/strtool-strings.out",
+    ]
     worker9 = subprocess.Popen(command8)
     print(worker9.communicate())
 
 
-
 def main():
-    args = parse_args()    
+    args = parse_args()
     ensure_dir(args.tokenpath)
-    #copy_tokens(args.cur, args.tokenpath)
+    # copy_tokens(args.cur, args.tokenpath)
     codeql_analysis(args.cur, args.db)
     copy_tokens(args.cur, args.tokenpath)
-    #start_autodict(args.tokenpath, args.cur)
-if __name__ == '__main__':
-    main()
\ No newline at end of file
+    # start_autodict(args.tokenpath, args.cur)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/utils/autodict_ql/litan.py b/utils/autodict_ql/litan.py
index 18c04c34..7033d363 100644
--- a/utils/autodict_ql/litan.py
+++ b/utils/autodict_ql/litan.py
@@ -4,7 +4,7 @@
 # Author : Microsvuln - Arash.vre@gmail.com
 import string
 import os
-import binascii 
+import binascii
 import codecs
 import struct
 import errno
@@ -12,75 +12,101 @@ import argparse
 import re
 import base64
 from binascii import unhexlify
+
+
 def parse_args():
-    parser = argparse.ArgumentParser(description=(
-        "Helper - Specify input file to analysis and output folder to save corpdirus for constants in the overall project -------  Example usage : python2 thisfile.py outdir o.txt"))
-    parser.add_argument("corpdir",
-        help="The path to the corpus directory to generate files.")
-    parser.add_argument("infile",
-        help="Specify file output of codeql analysis - ex. ooo-hex.txt, analysis take place on this file, example : python2 thisfile.py outdir out.txt")
-    return parser.parse_args()    
+    parser = argparse.ArgumentParser(
+        description=(
+            "Helper - Specify input file to analysis and output folder to save corpdirus for constants in the overall project -------  Example usage : python2 thisfile.py outdir o.txt"
+        )
+    )
+    parser.add_argument(
+        "corpdir", help="The path to the corpus directory to generate files."
+    )
+    parser.add_argument(
+        "infile",
+        help="Specify file output of codeql analysis - ex. ooo-hex.txt, analysis take place on this file, example : python2 thisfile.py outdir out.txt",
+    )
+    return parser.parse_args()
+
+
 def ensure_dir(dir):
     try:
         os.makedirs(dir)
     except OSError as e:
         if e.errno == errno.EEXIST:
-            #print "[-] Directory exists, specify another directory"
+            # print "[-] Directory exists, specify another directory"
             exit(1)
+
+
 def do_analysis1(corpdir, infile):
-    with open(infile, "rb") as f:        
-        lines = f.readlines()[1:]       
-        f.close()       
+    with open(infile, "rb") as f:
+        lines = f.readlines()[1:]
+        f.close()
         new_lst = []
         n = 1
         for i, num in enumerate(lines):
             if i != 0:
-                new_lst.append(num)                               
+                new_lst.append(num)
                 str1 = str(num)
-                print ("num is " + str1)
-                str1 = str1.rstrip('\n\n')
-                #str1 = str1.replace("0x","");
-                str1 = str1.replace("|","")
-                str1 = str1.rstrip('\r\n')
-                str1 = str1.rstrip('\n')
-                str1 = str1.replace(" ","")
-                    #str1 = str1.translate(None, string.punctuation)
-                translator=str.maketrans('','',string.punctuation)
-                str1=str1.translate(translator)
+                print("num is " + str1)
+                str1 = str1.rstrip("\n\n")
+                # str1 = str1.replace("0x","");
+                str1 = str1.replace("|", "")
+                str1 = str1.rstrip("\r\n")
+                str1 = str1.rstrip("\n")
+                str1 = str1.replace(" ", "")
+                # str1 = str1.translate(None, string.punctuation)
+                translator = str.maketrans("", "", string.punctuation)
+                str1 = str1.translate(translator)
                 str1 = str1[1:]
                 str1 = str1[:-1]
                 print("After cleanup : " + str1)
-                if (str1 != '0') and (str1 != 'ffffffff') and (str1 != 'fffffffe') or (len(str1) == 4) or (len(str1) == 8):
-                    print ("first : "+str1)
-                    if len(str1) > 8 :
+                if (
+                    (str1 != "0")
+                    and (str1 != "ffffffff")
+                    and (str1 != "fffffffe")
+                    or (len(str1) == 4)
+                    or (len(str1) == 8)
+                ):
+                    print("first : " + str1)
+                    if len(str1) > 8:
                         str1 = str1[:-1]
-                    elif (len(str1) == 5) :
+                    elif len(str1) == 5:
                         str1 = str1 = "0"
                     try:
-                            #str1 = str1.decode("hex")
-                            with open(corpdir+'/lit-seed{0}'.format(n), 'w') as file:                    
-                                    str1 = str1.replace("0x","");
-                                    print (str1)                                    
-                                    str1 = int(str1,base=16)                                    
-                                    str1 = str1.to_bytes(4, byteorder='little')                                                          
-                                    file.write(str(str1))                                    
-                                    file.close()
-                                    with open (corpdir+'/lit-seed{0}'.format(n), 'r') as q :
-                                        a = q.readline()                                        
-                                        a = a[1:]
-                                        print ("AFL++ Autodict-QL by Microsvuln : Writing Token :" + str(a))
-                                        q.close()
-                                        with open (corpdir+'/lit-seed{0}'.format(n), 'w') as w1 :
-                                                w1.write(str(a))
-                                                print ("Done!")
-                                                w1.close()                                                                                
-                    except:                                 
-                            print("Error!") 
-                    n = n+1
+                        # str1 = str1.decode("hex")
+                        with open(corpdir + "/lit-seed{0}".format(n), "w") as file:
+                            str1 = str1.replace("0x", "")
+                            print(str1)
+                            str1 = int(str1, base=16)
+                            str1 = str1.to_bytes(4, byteorder="little")
+                            file.write(str(str1))
+                            file.close()
+                            with open(corpdir + "/lit-seed{0}".format(n), "r") as q:
+                                a = q.readline()
+                                a = a[1:]
+                                print(
+                                    "AFL++ Autodict-QL by Microsvuln : Writing Token :"
+                                    + str(a)
+                                )
+                                q.close()
+                                with open(
+                                    corpdir + "/lit-seed{0}".format(n), "w"
+                                ) as w1:
+                                    w1.write(str(a))
+                                    print("Done!")
+                                    w1.close()
+                    except:
+                        print("Error!")
+                    n = n + 1
+
 
 def main():
-    args = parse_args()    
+    args = parse_args()
     ensure_dir(args.corpdir)
     do_analysis1(args.corpdir, args.infile)
-if __name__ == '__main__':
-    main()
\ No newline at end of file
+
+
+if __name__ == "__main__":
+    main()
diff --git a/utils/autodict_ql/memcmp-strings.py b/utils/autodict_ql/memcmp-strings.py
index d1047caa..270a697c 100644
--- a/utils/autodict_ql/memcmp-strings.py
+++ b/utils/autodict_ql/memcmp-strings.py
@@ -5,7 +5,7 @@
 
 import os
 import string
-import binascii 
+import binascii
 import codecs
 import errno
 import struct
@@ -13,6 +13,7 @@ import argparse
 import re
 from binascii import unhexlify
 
+
 def ensure_dir(dir):
     try:
         os.makedirs(dir)
@@ -20,44 +21,63 @@ def ensure_dir(dir):
         if e.errno != errno.EEXIST:
             raise
 
+
 def parse_args():
-    parser = argparse.ArgumentParser(description=(
-        "Helper - Specify input file analysis and output folder to save corpus for strings in the overall project ---------------------------------------------------------------------------  Example usage : python2 thisfile.py outdir str.txt"    ))
-    parser.add_argument("corpdir",
-        help="The path to the corpus directory to generate strings.")
-    parser.add_argument("infile",
-        help="Specify file output of codeql analysis - ex. ooo-atr.txt, analysis take place on this file, example : python2 thisfile.py outdir strings.txt")
+    parser = argparse.ArgumentParser(
+        description=(
+            "Helper - Specify input file analysis and output folder to save corpus for strings in the overall project ---------------------------------------------------------------------------  Example usage : python2 thisfile.py outdir str.txt"
+        )
+    )
+    parser.add_argument(
+        "corpdir", help="The path to the corpus directory to generate strings."
+    )
+    parser.add_argument(
+        "infile",
+        help="Specify file output of codeql analysis - ex. ooo-atr.txt, analysis take place on this file, example : python2 thisfile.py outdir strings.txt",
+    )
 
     return parser.parse_args()
 
 
 def do_string_analysis(corpdir, infile1):
-    with open(infile1, "r") as f1:        
-        lines = f1.readlines()[1:]       
-        f1.close()       
+    with open(infile1, "r") as f1:
+        lines = f1.readlines()[1:]
+        f1.close()
         new_lst1 = []
         n = 1
         for i, num1 in enumerate(lines):
             if i != 0:
                 new_lst1.append(num1)
-                #print("num : %s" % num1)
+                # print("num : %s" % num1)
                 str11 = str(num1)
-                str11 = str11.replace("|","")
-                str11 = str11.replace("\n","")
+                str11 = str11.replace("|", "")
+                str11 = str11.replace("\n", "")
                 str11 = str11.lstrip()
                 str11 = str11.rstrip()
                 str11 = str(str11)
-                if ((" " in str11 ) or (")" in str11) or ("(" in str11) or ("<" in str11) or (">" in str11)) :
+                if (
+                    (" " in str11)
+                    or (")" in str11)
+                    or ("(" in str11)
+                    or ("<" in str11)
+                    or (">" in str11)
+                ):
                     print("Space / Paranthesis String : %s" % str11)
-                else :
-                    with open(corpdir+'/memcmp-str{0}'.format(n), 'w') as file:                    
-                            file.write(str11)
-                            print("AFL++ Autodict-QL by Microsvuln : Writing Token : %s" % str11)
-                            n=n+1
+                else:
+                    with open(corpdir + "/memcmp-str{0}".format(n), "w") as file:
+                        file.write(str11)
+                        print(
+                            "AFL++ Autodict-QL by Microsvuln : Writing Token : %s"
+                            % str11
+                        )
+                        n = n + 1
+
 
 def main():
-    args = parse_args()    
+    args = parse_args()
     ensure_dir(args.corpdir)
     do_string_analysis(args.corpdir, args.infile)
-if __name__ == '__main__':
-    main()
\ No newline at end of file
+
+
+if __name__ == "__main__":
+    main()
diff --git a/utils/autodict_ql/stan-strings.py b/utils/autodict_ql/stan-strings.py
index 65d08c97..81cb0b97 100644
--- a/utils/autodict_ql/stan-strings.py
+++ b/utils/autodict_ql/stan-strings.py
@@ -5,7 +5,7 @@
 
 import os
 import string
-import binascii 
+import binascii
 import codecs
 import errno
 import struct
@@ -13,6 +13,7 @@ import argparse
 import re
 from binascii import unhexlify
 
+
 def ensure_dir(dir):
     try:
         os.makedirs(dir)
@@ -20,44 +21,63 @@ def ensure_dir(dir):
         if e.errno != errno.EEXIST:
             raise
 
+
 def parse_args():
-    parser = argparse.ArgumentParser(description=(
-        "Helper - Specify input file analysis and output folder to save corpus for strings in the overall project ---------------------------------------------------------------------------  Example usage : python2 thisfile.py outdir str.txt"    ))
-    parser.add_argument("corpdir",
-        help="The path to the corpus directory to generate strings.")
-    parser.add_argument("infile",
-        help="Specify file output of codeql analysis - ex. ooo-atr.txt, analysis take place on this file, example : python2 thisfile.py outdir strings.txt")
+    parser = argparse.ArgumentParser(
+        description=(
+            "Helper - Specify input file analysis and output folder to save corpus for strings in the overall project ---------------------------------------------------------------------------  Example usage : python2 thisfile.py outdir str.txt"
+        )
+    )
+    parser.add_argument(
+        "corpdir", help="The path to the corpus directory to generate strings."
+    )
+    parser.add_argument(
+        "infile",
+        help="Specify file output of codeql analysis - ex. ooo-atr.txt, analysis take place on this file, example : python2 thisfile.py outdir strings.txt",
+    )
 
     return parser.parse_args()
 
 
 def do_string_analysis(corpdir, infile1):
-    with open(infile1, "r") as f1:        
-        lines = f1.readlines()[1:]       
-        f1.close()       
+    with open(infile1, "r") as f1:
+        lines = f1.readlines()[1:]
+        f1.close()
         new_lst1 = []
         n = 1
         for i, num1 in enumerate(lines):
             if i != 0:
                 new_lst1.append(num1)
-                #print("num : %s" % num1)
+                # print("num : %s" % num1)
                 str11 = str(num1)
-                str11 = str11.replace("|","")
-                str11 = str11.replace("\n","")
+                str11 = str11.replace("|", "")
+                str11 = str11.replace("\n", "")
                 str11 = str11.lstrip()
                 str11 = str11.rstrip()
                 str11 = str(str11)
-                if ((" " in str11 ) or (")" in str11) or ("(" in str11) or ("<" in str11) or (">" in str11)) :
+                if (
+                    (" " in str11)
+                    or (")" in str11)
+                    or ("(" in str11)
+                    or ("<" in str11)
+                    or (">" in str11)
+                ):
                     print("Space / Paranthesis String : %s" % str11)
-                else :
-                    with open(corpdir+'/seed-str{0}'.format(n), 'w') as file:                    
-                            file.write(str11)
-                            print("AFL++ Autodict-QL by Microsvuln : Writing Token : %s" % str11)
-                            n=n+1
+                else:
+                    with open(corpdir + "/seed-str{0}".format(n), "w") as file:
+                        file.write(str11)
+                        print(
+                            "AFL++ Autodict-QL by Microsvuln : Writing Token : %s"
+                            % str11
+                        )
+                        n = n + 1
+
 
 def main():
-    args = parse_args()    
+    args = parse_args()
     ensure_dir(args.corpdir)
     do_string_analysis(args.corpdir, args.infile)
-if __name__ == '__main__':
-    main()
\ No newline at end of file
+
+
+if __name__ == "__main__":
+    main()
diff --git a/utils/autodict_ql/strcmp-strings.py b/utils/autodict_ql/strcmp-strings.py
index 88128dbb..9c2520c9 100644
--- a/utils/autodict_ql/strcmp-strings.py
+++ b/utils/autodict_ql/strcmp-strings.py
@@ -5,7 +5,7 @@
 
 import os
 import string
-import binascii 
+import binascii
 import codecs
 import errno
 import struct
@@ -13,6 +13,7 @@ import argparse
 import re
 from binascii import unhexlify
 
+
 def ensure_dir(dir):
     try:
         os.makedirs(dir)
@@ -20,44 +21,63 @@ def ensure_dir(dir):
         if e.errno != errno.EEXIST:
             raise
 
+
 def parse_args():
-    parser = argparse.ArgumentParser(description=(
-        "Helper - Specify input file analysis and output folder to save corpus for strings in the overall project ---------------------------------------------------------------------------  Example usage : python2 thisfile.py outdir str.txt"    ))
-    parser.add_argument("corpdir",
-        help="The path to the corpus directory to generate strings.")
-    parser.add_argument("infile",
-        help="Specify file output of codeql analysis - ex. ooo-atr.txt, analysis take place on this file, example : python2 thisfile.py outdir strings.txt")
+    parser = argparse.ArgumentParser(
+        description=(
+            "Helper - Specify input file analysis and output folder to save corpus for strings in the overall project ---------------------------------------------------------------------------  Example usage : python2 thisfile.py outdir str.txt"
+        )
+    )
+    parser.add_argument(
+        "corpdir", help="The path to the corpus directory to generate strings."
+    )
+    parser.add_argument(
+        "infile",
+        help="Specify file output of codeql analysis - ex. ooo-atr.txt, analysis take place on this file, example : python2 thisfile.py outdir strings.txt",
+    )
 
     return parser.parse_args()
 
 
 def do_string_analysis(corpdir, infile1):
-    with open(infile1, "r") as f1:        
-        lines = f1.readlines()[1:]       
-        f1.close()       
+    with open(infile1, "r") as f1:
+        lines = f1.readlines()[1:]
+        f1.close()
         new_lst1 = []
         n = 1
         for i, num1 in enumerate(lines):
             if i != 0:
                 new_lst1.append(num1)
-                #print("num : %s" % num1)
+                # print("num : %s" % num1)
                 str11 = str(num1)
-                str11 = str11.replace("|","")
-                str11 = str11.replace("\n","")
+                str11 = str11.replace("|", "")
+                str11 = str11.replace("\n", "")
                 str11 = str11.lstrip()
                 str11 = str11.rstrip()
                 str11 = str(str11)
-                if ((" " in str11 ) or (")" in str11) or ("(" in str11) or ("<" in str11) or (">" in str11)) :
+                if (
+                    (" " in str11)
+                    or (")" in str11)
+                    or ("(" in str11)
+                    or ("<" in str11)
+                    or (">" in str11)
+                ):
                     print("Space / Paranthesis String : %s" % str11)
-                else :
-                    with open(corpdir+'/strcmp-str{0}'.format(n), 'w') as file:                    
-                            file.write(str11)
-                            print("AFL++ Autodict-QL by Microsvuln : Writing Token : %s" % str11)
-                            n=n+1
+                else:
+                    with open(corpdir + "/strcmp-str{0}".format(n), "w") as file:
+                        file.write(str11)
+                        print(
+                            "AFL++ Autodict-QL by Microsvuln : Writing Token : %s"
+                            % str11
+                        )
+                        n = n + 1
+
 
 def main():
-    args = parse_args()    
+    args = parse_args()
     ensure_dir(args.corpdir)
     do_string_analysis(args.corpdir, args.infile)
-if __name__ == '__main__':
-    main()
\ No newline at end of file
+
+
+if __name__ == "__main__":
+    main()
diff --git a/utils/autodict_ql/strncmp-strings.py b/utils/autodict_ql/strncmp-strings.py
index 0ad0e697..6206b4c4 100644
--- a/utils/autodict_ql/strncmp-strings.py
+++ b/utils/autodict_ql/strncmp-strings.py
@@ -5,7 +5,7 @@
 
 import os
 import string
-import binascii 
+import binascii
 import codecs
 import errno
 import struct
@@ -13,6 +13,7 @@ import argparse
 import re
 from binascii import unhexlify
 
+
 def ensure_dir(dir):
     try:
         os.makedirs(dir)
@@ -20,44 +21,63 @@ def ensure_dir(dir):
         if e.errno != errno.EEXIST:
             raise
 
+
 def parse_args():
-    parser = argparse.ArgumentParser(description=(
-        "Helper - Specify input file analysis and output folder to save corpus for strings in the overall project ---------------------------------------------------------------------------  Example usage : python2 thisfile.py outdir str.txt"    ))
-    parser.add_argument("corpdir",
-        help="The path to the corpus directory to generate strings.")
-    parser.add_argument("infile",
-        help="Specify file output of codeql analysis - ex. ooo-atr.txt, analysis take place on this file, example : python2 thisfile.py outdir strings.txt")
+    parser = argparse.ArgumentParser(
+        description=(
+            "Helper - Specify input file analysis and output folder to save corpus for strings in the overall project ---------------------------------------------------------------------------  Example usage : python2 thisfile.py outdir str.txt"
+        )
+    )
+    parser.add_argument(
+        "corpdir", help="The path to the corpus directory to generate strings."
+    )
+    parser.add_argument(
+        "infile",
+        help="Specify file output of codeql analysis - ex. ooo-atr.txt, analysis take place on this file, example : python2 thisfile.py outdir strings.txt",
+    )
 
     return parser.parse_args()
 
 
 def do_string_analysis(corpdir, infile1):
-    with open(infile1, "r") as f1:        
-        lines = f1.readlines()[1:]       
-        f1.close()       
+    with open(infile1, "r") as f1:
+        lines = f1.readlines()[1:]
+        f1.close()
         new_lst1 = []
         n = 1
         for i, num1 in enumerate(lines):
             if i != 0:
                 new_lst1.append(num1)
-                #print("num : %s" % num1)
+                # print("num : %s" % num1)
                 str11 = str(num1)
-                str11 = str11.replace("|","")
-                str11 = str11.replace("\n","")
+                str11 = str11.replace("|", "")
+                str11 = str11.replace("\n", "")
                 str11 = str11.lstrip()
                 str11 = str11.rstrip()
                 str11 = str(str11)
-                if ((" " in str11 ) or (")" in str11) or ("(" in str11) or ("<" in str11) or (">" in str11)) :
+                if (
+                    (" " in str11)
+                    or (")" in str11)
+                    or ("(" in str11)
+                    or ("<" in str11)
+                    or (">" in str11)
+                ):
                     print("Space / Paranthesis String : %s" % str11)
-                else :
-                    with open(corpdir+'/strncmp-str{0}'.format(n), 'w') as file:                    
-                            file.write(str11)
-                            print("AFL++ Autodict-QL by Microsvuln : Writing Token : %s" % str11)
-                            n=n+1
+                else:
+                    with open(corpdir + "/strncmp-str{0}".format(n), "w") as file:
+                        file.write(str11)
+                        print(
+                            "AFL++ Autodict-QL by Microsvuln : Writing Token : %s"
+                            % str11
+                        )
+                        n = n + 1
+
 
 def main():
-    args = parse_args()    
+    args = parse_args()
     ensure_dir(args.corpdir)
     do_string_analysis(args.corpdir, args.infile)
-if __name__ == '__main__':
-    main()
\ No newline at end of file
+
+
+if __name__ == "__main__":
+    main()
-- 
cgit 1.4.1