This PR is a result of integration with QIRA.

The PR will bring us the following:

1. BAP now supports 25 different architectures.
   Also Arch module can now infer address size and endianness from the
   specified architecture.

2. Bap server doesn't require address size or endian.
   Only arch is required, everything else can be inferred from it.

3. Addresses in Public API is no longer an ADT but a string encoded
   number, with value specified strictly in hexes.

4. BIL and ADT classes are extended.
   Added some helpers, and also add named properties to BIL entities.

5. Updated README.md and simplified installation.
   This will resolve #62

6. Packaged server a little more accurately, although it still
   not pluginized (see #67)

7. Hardened `bap.py` for multithreaded environment
   bap will try to autospawn one server per process, and multiple
   bap proxies will be created per thread

8. bap-mc now accepts more user inputs:
   1. bytes can be separated with spaces, commas and semicolons
   2. bytes can be left without separators

9. bap-mc will now error in case of error
   This is to resolve #47 and others

10. bap-mc will now properly handle invalid instructions
   Previously there was a bug, as a result error handler was applied
   prematurely. Also, I've extended error handler with pretty-printer
   that will output dump, highlighting failed piece of code.

11. readbin will linear sweep executable sections if there are no
    symbol information.

12. bap-server if ordered to disassemble the whole image will
   disassemble only executable part of the file. I think this is a more
   reasonable behavior, rather than previously to disassemble the whole
   file including data sections.

Author: ivg

__init__.py

@@ -99,6 +99,6 @@
 
 Where data is actual string of bytes.
 """
-__all__ = ['disasm', 'image']
+__all__ = ['disasm', 'image', 'adt', 'asm', 'arm', 'bil']
 
 from .bap import disasm, image

adt.py

@@ -57,25 +57,27 @@ class ADT(object):
 
     """
     def __init__(self, *args):
-        self.name = self.__class__.__name__
-        self.val = args if len(args) != 1 else args[0]
+        self.constr = self.__class__.__name__
+        self.arg = args if len(args) != 1 else args[0]
 
     def __cmp__(self,other):
         return self.__dict__.__cmp__(other.__dict__)
 
     def __repr__(self):
         def qstr(x):
-            if isinstance(x, int) or isinstance(x, ADT):
+            if isinstance(x, (int,long)):
+                return '0x{0:x}'.format(x)
+            elif isinstance(x, ADT):
                 return str(x)
             else:
                 return '"{0}"'.format(x)
         def args():
-            if isinstance(self.val, tuple):
-                return ", ".join(qstr(x) for x in self.val)
+            if isinstance(self.arg, tuple):
+                return ", ".join(qstr(x) for x in self.arg)
             else:
-                return qstr(self.val)
+                return qstr(self.arg)
 
-        return "{0}({1})".format(self.name, args())
+        return "{0}({1})".format(self.constr, args())
 
 
 class Visitor(object):
@@ -96,9 +98,12 @@ def visit_ADT(self, adt):
         no specific visitors. It will recursively descent into all
         ADT values.
         """
-        if isinstance(adt.val, tuple):
-            for e in adt.val:
+        if isinstance(adt.arg, tuple):
+            for e in adt.arg:
                 self.run(e)
+        elif isinstance(adt.arg, ADT):
+            self.run(adt.arg)
+
 
     def run(self, adt):
         """ADT.run(adt-or-iterable) -> None
@@ -126,14 +131,14 @@ def __init__(self):
                 self.count = 0
 
             def visit_Int(self, int):
-                if int.val < 0 and not self.neg \
-                  or int.val > 0 and self.neg:
+                if int.arg < 0 and not self.neg \
+                  or int.arg > 0 and self.neg:
                     self.count += 1
 
             def visit_NEG(self, op):
                 was = self.neg
                 self.neg = not was
-                self.run(op.val)
+                self.run(op.arg)
                 self.neg = was
 
         We need to keep track on the unary negation operator, and, of
@@ -147,9 +152,6 @@ def visit_NEG(self, op):
         and recurse into the operand. After we return from the recursion, we restore
         the sign.
         """
-        if isinstance(adt, Iterable):
-            for s in adt:
-                self.run(s)
         if isinstance(adt, ADT):
             for c in adt.__class__.mro():
                 name = ("visit_%s" % c.__name__)
@@ -158,6 +160,16 @@ def visit_NEG(self, op):
                     return fn(adt)
 
 
+def visit(visitor, adt):
+
+    if isinstance(adt, Iterable):
+        for x in adt:
+            visitor.run(x)
+    else:
+        visitor.run(adt)
+    return visitor
+
+
 if __name__ == "__main__":
     class Fruit(ADT) : pass
     class Bannana(Fruit) : pass

asm.py

@@ -34,7 +34,7 @@ def map_eval(ss):
 
 
 class Insn(object) :
-    def __init__(self, name, addr, size, asm, kinds, operands, target=None, bil=[], **kw):
+    def __init__(self, name, addr, size, asm, kinds, operands, target=None, bil=None, **kw):
         self.name  = name
         self.addr  = int(addr)
         self.size  = int(size)
@@ -45,8 +45,11 @@ def __init__(self, name, addr, size, asm, kinds, operands, target=None, bil=[],
         self.bil = bil
         self.__dict__.update(kw)
 
+    def has_kind(self, k):
+        return exists(self.kinds, lambda x: isinstance(x,k))
+
     def __repr__(self):
-        return 'Insn("{name}", {addr:#010x}, {size}, "{asm}", {kinds}, {operands}, {target}, {bil})'.\
+        return 'Insn("{name}", {addr:#010x}, {size}, "{asm}", {kinds}, {operands})'.\
           format(**self.__dict__)
 
 class Op(ADT)        : pass
@@ -55,6 +58,14 @@ class Imm(Op)        : pass
 class Fmm(Op)        : pass
 
 
+def exists(cont,f):
+    try:
+        r = (x for x in cont if f(x)).next()
+        return True
+    except StopIteration:
+        return False
+
+
 if __name__ == "__main__":
     print Reg('R0')
     for insn in ["Reg(\"R0\")", "Imm(5)", "Imm(14)", "Reg(\"Nil\")", "Reg(\"Nil\")"]:

bap.py

@@ -2,6 +2,7 @@
 # -*- coding: utf-8 -*-
 
 import os, time, atexit
+from signal import signal, SIGTERM
 import requests
 from subprocess import Popen
 from mmap import mmap
@@ -10,41 +11,64 @@
 import json
 import adt, arm, asm, bil
 
+import threading
+
+from pprint import pprint
+
 
 __all__ = ["disasm", "image"]
 
 DEBUG_LEVEL = ["Critical", "Error"]
 
-instance = None
+
+storage = threading.local()
+servers = dict()
+server_lock = threading.Lock()
 
 def del_instance():
+    instance = getattr(storage, 'instance', None)
     if instance is not None:
         instance.close()
 
 def get_instance(**kwargs):
-    global instance
-    if 'server' in kwargs or instance is None:
-        if instance is not None:
-            instance.close()
+    instance = getattr(storage, 'instance', None)
+    if instance is None:
         args = kwargs.get('server', {})
-        instance = Bap(args)
-    return instance
+        storage.instance = Bap(args)
+    return storage.instance
 
 atexit.register(del_instance)
+signal(SIGTERM, lambda x,y: del_instance)
+
+
+def spawn_server(**kwargs):
+    port = str(kwargs.get('port', 8080))
+    name = kwargs.get('name', 'bap-server')
+    with server_lock:
+        if port in servers:
+            return servers[port]
+        else:
+            process = Popen([name, '--port=' + port])
+            server  = {
+                'server' : process,
+                'url' : "http://127.0.0.1:{0}".format(port)
+            }
+            servers[port] = server
+            return server
+
 
 def disasm(obj, **kwargs):
     r""" disasm(obj) disassembles provided object.
     Returns a generator object yield instructions.
-
     """
-    def ret(obj):
-        return get_instance(**kwargs).insns(obj)
+    def run(obj):
+        return get_instance(**kwargs).insns(obj, **kwargs)
     if isinstance(obj, Id):
-        return ret(obj)
+        return run(obj)
     elif isinstance(obj, Resource):
-        return ret(obj.ident)
+        return run(obj.ident)
     else:
-        return ret(load_chunk(obj, **kwargs))
+        return run(load_chunk(obj, **kwargs))
 
 def image(f, **kwargs):
     bap = get_instance(**kwargs)
@@ -218,10 +242,12 @@ def __init__(self, server={}):
             raise RuntimeError("Failed to connect to BAP server")
 
         self.data = {}
-        self.temp = NamedTemporaryFile('rw+b')
+        self.temp = NamedTemporaryFile('rw+b', prefix="bap-")
 
-    def insns(self, src):
-        res = self.call({'get_insns' : {'resource' : src}})
+    def insns(self, src, **kwargs):
+        req = {'resource' : src}
+        req.update(kwargs)
+        res = self.call({'get_insns' : req})
         for msg in res:
             if 'error' in msg:
                 err = Error(msg)
@@ -242,9 +268,13 @@ def get_resource(self, name):
 
     def load_chunk(self, data, **kwargs):
         kwargs.setdefault('url', self.mmap(data))
-        kwargs.setdefault('arch', 'x86_32')
-        kwargs.setdefault('address', bil.Int(0,32))
-        kwargs.setdefault('endian', bil.LittleEndian())
+        kwargs.setdefault('arch', 'i386')
+        kwargs.setdefault('addr', 0)
+        addr = kwargs['addr']
+        if isinstance(addr, str):
+            addr = long(addr, 0)
+        kwargs['addr'] = '0x{0:x}'.format(addr)
+
         return self._load_resource({'load_memory_chunk' : kwargs})
 
     def __exit__(self):
@@ -270,8 +300,8 @@ def dumps(dic):
     def mmap(self, data):
         url = "mmap://{0}?offset=0&length={1}".format(
             self.temp.name, len(data))
-        os.ftruncate(self.temp.fileno(), len(data))
-        mm = mmap(self.temp.fileno(), len(data))
+        os.ftruncate(self.temp.fileno(), 4096)
+        mm = mmap(self.temp.fileno(), 4096)
         mm.write(data)
         mm.close()
         return url
@@ -282,14 +312,6 @@ def _load_resource(self, res):
             raise ServerError(rep)
         return Id(rep['resource'])
 
-def spawn_server(**kwargs):
-    port = kwargs.get('port', 8080)
-    name = kwargs.get('name', 'bap-server')
-    server = Popen([name, '--port=' + str(port)])
-    return {
-        'server' : server,
-        'url' : "http://127.0.0.1:{0}".format(port)
-    }
 
 def jsons(r, p=0):
     dec = json.JSONDecoder(encoding='utf-8')