contrast-agent 3.8.4

data/funchook/distorm/python/distorm3/sample.py

@@ -0,0 +1,51 @@
+# Mario Vilas, http://breakingcode.wordpress.com
+# Licensed under BSD in 2016
+
+# Example code
+
+import distorm3
+import sys
+import optparse
+
+# Parse the command line arguments
+usage  = 'Usage: %prog [--b16 | --b32 | --b64] filename [offset]'
+parser = optparse.OptionParser(usage=usage)
+parser.add_option(  '--b16', help='80286 decoding',
+                    action='store_const', dest='dt', const=distorm3.Decode16Bits  )
+parser.add_option(  '--b32', help='IA-32 decoding [default]',
+                    action='store_const', dest='dt', const=distorm3.Decode32Bits  )
+parser.add_option(  '--b64', help='AMD64 decoding',
+                    action='store_const', dest='dt', const=distorm3.Decode64Bits  )
+parser.set_defaults(dt=distorm3.Decode32Bits)
+options, args = parser.parse_args(sys.argv)
+if len(args) < 2:
+    parser.error('missing parameter: filename')
+filename = args[1]
+offset   = 0
+length   = None
+if len(args) == 3:
+    try:
+        offset = int(args[2], 10)
+    except ValueError:
+        parser.error('invalid offset: %s' % args[2])
+    if offset < 0:
+        parser.error('invalid offset: %s' % args[2])
+elif len(args) > 3:
+    parser.error('too many parameters')
+
+# Read the code from the file
+try:
+    code = open(filename, 'rb').read()
+except Exception as e:
+    parser.error('error reading file %s: %s' % (filename, e))
+
+# Print each decoded instruction
+# This shows how to use the Deocode - Generator
+iterable = distorm3.DecodeGenerator(offset, code, options.dt)
+for (offset, size, instruction, hexdump) in iterable:
+    print("%.8x: %-32s %s" % (offset, hexdump, instruction))
+
+# It could also be used as a returned list:
+# l = distorm3.Decode(offset, code, options.dt)
+# for (offset, size, instruction, hexdump) in l:
+#     print("%.8x: %-32s %s" % (offset, hexdump, instruction))

data/funchook/distorm/setup.cfg

@@ -0,0 +1,10 @@
+[wheel]
+universal = 1
+
+[install]
+force=1
+compile=1
+optimize=1
+
+[bdist_wininst]
+user-access-control=auto

data/funchook/distorm/setup.py

@@ -0,0 +1,266 @@
+#!/usr/bin/env python
+
+# Copyright (c) 2009, Mario Vilas
+# Rob Ruana 2010
+# Gil Dabah
+# All rights reserved.
+# Licensed under BSD.
+#
+
+__revision__ = "$Id: setup.py 603 2010-01-31 00:11:05Z qvasimodo $"
+
+import os
+import platform
+import string
+import shutil
+import sys
+
+from glob import glob
+
+from distutils import log
+from distutils.command.build import build
+from distutils.command.build_clib import build_clib
+from distutils.command.clean import clean
+from distutils.command.install_lib import install_lib
+from distutils.command.sdist import sdist
+from distutils.core import setup, Extension
+from distutils.errors import DistutilsSetupError
+
+from shutil import ignore_patterns
+
+def get_sources():
+    """Returns a list of C source files that should be compiled to 
+    create the libdistorm3 library.
+    """
+
+    return glob('src/*.c')
+
+
+class custom_build(build):
+    """Customized build command"""
+    def run(self):
+        log.info('running custom_build')
+        build.run(self)
+
+
+class custom_build_clib(build_clib):
+    """Customized build_clib command
+
+    This custom_build_clib will create dynamically linked libraries rather 
+    than statically linked libraries.  In addition, it places the compiled 
+    libraries alongside the python packages, to facilitate the use of ctypes. 
+    """
+
+    def finalize_options (self):
+        # We want build-clib to default to build-lib as defined by the 
+        # "build" command.  This is so the compiled library will be put 
+        # in the right place along side the python code.
+        self.set_undefined_options('build',
+                                   ('build_lib', 'build_clib'),
+                                   ('build_temp', 'build_temp'),
+                                   ('compiler', 'compiler'),
+                                   ('debug', 'debug'),
+                                   ('force', 'force'))
+
+        self.libraries = self.distribution.libraries
+        if self.libraries: # In Python 3.0 they have a bug in check_library_list, comment it out then.
+            self.check_library_list(self.libraries)
+
+        if self.include_dirs is None:
+            self.include_dirs = self.distribution.include_dirs or []
+        if type(self.include_dirs) in (bytes, str):
+            self.include_dirs = string.split(self.include_dirs,
+                                             os.pathsep)
+
+    def get_source_files_for_lib(self, lib_name, build_info):
+        sources = build_info.get('sources', [])
+        if hasattr(sources, '__call__'):
+            sources = sources()
+        if (sources is None or
+            type(sources) not in (list, tuple) or
+            len(sources) == 0):
+            raise DistutilsSetupError ("in 'libraries' option (library '%s'), 'sources' must be present and must be a list of source filenames") % lib_name
+        return sources
+
+    def get_source_files(self):
+        self.check_library_list(self.libraries)
+        filenames = []
+        for (lib_name, build_info) in self.libraries:
+            sources = self.get_source_files_for_lib(lib_name, build_info)
+            filenames.extend(sources)
+        return filenames
+
+    def run(self):
+        log.info('running custom_build_clib')
+        build_clib.run(self)
+
+    def build_libraries (self, libraries):
+        for (lib_name, build_info) in libraries:
+            sources = self.get_source_files_for_lib(lib_name, build_info)
+            sources = list(sources)
+
+            log.info("building '%s' library", lib_name)
+
+            # First, compile the source code to object files in the 
+            # library directory.
+            macros = build_info.get('macros')
+            include_dirs = build_info.get('include_dirs')
+            objects = self.compiler.compile(sources,
+                output_dir=self.build_temp,
+                macros=macros,
+                include_dirs=include_dirs,
+                extra_postargs=build_info.get('extra_compile_args', []),
+                debug=self.debug)
+
+            # Then link the object files and put the result in the 
+            # package build directory.
+            package = build_info.get('package', '')
+            self.compiler.link_shared_lib(
+                objects, lib_name,
+                output_dir=os.path.join(self.build_clib, package),
+                extra_postargs=build_info.get('extra_link_args', []),
+                debug=self.debug,)
+
+
+class custom_clean(clean):
+    """Customized clean command
+
+    Customized clean command removes .pyc files from the project, 
+    as well as build and dist directories."""
+    def run(self):
+        log.info('running custom_clean')
+        # Remove .pyc files
+        if hasattr(os, 'walk'):
+            for root, dirs, files in os.walk('.'):
+                for f in files:
+                    if f.endswith('.pyc'):
+                        log.info("removing '%s'" % f)
+                        try:
+                            os.unlink(f)
+                        except:
+                            pass
+
+        # Remove generated directories
+        for dir in ['build', 'dist']:
+            if os.path.exists(dir):
+                log.info("removing '%s' (and everything under it)"%dir)
+                try:
+                    shutil.rmtree(dir, ignore_errors=True)
+                except:
+                    pass
+
+        clean.run(self)
+
+
+class custom_sdist(sdist):
+    """Customized sdist command"""
+    def run(self):
+        log.info('running custom_sdist')
+        sdist.run(self)
+
+
+def main():
+    # Just in case we are being called from a different directory
+    cwd = os.path.dirname(__file__)
+    if cwd:
+        os.chdir(cwd)
+    
+    # Get the target platform
+    system  = platform.system().lower()
+    
+    # Setup the extension module
+    # Setup the library
+    ext_modules = None
+    libraries = None
+    if 'windows' in system:
+        libraries = [(
+            'distorm3', dict(
+            package='distorm3',
+            sources=get_sources,
+            include_dirs=['src', 'include'],
+            extra_compile_args=['/Ox', '/Ob1', '/Oy', '"/D WIN32"',
+                                '"/D DISTORM_DYNAMIC"', '"/D SUPPORT_64BIT_OFFSET"',
+                                '"/D _MBCS"', '/GF', '/Gm', '/Zi', '/EHsc',
+                                '/MT', '/Gy', '/W4', '/nologo', '/c', '/TC',
+                                '/Fdbuild\\vc90.pdb'],
+            extra_link_args=['/MANIFEST', '/DLL']))]
+    elif 'darwin' in system or 'macosx' in system:
+        libraries = [(
+            'distorm3', dict(
+            package='distorm3',
+            sources=get_sources,
+            include_dirs=['src', 'include'],
+            extra_compile_args=['-arch', 'i386', '-arch', 'x86_64', '-O2', 
+                                '-Wall', '-fPIC', '-DSUPPORT_64BIT_OFFSET', 
+                                '-DDISTORM_DYNAMIC']))]
+    elif 'cygwin' in system:
+        libraries = [(
+            'distorm3', dict(
+            package='distorm3',
+            sources=get_sources,
+            include_dirs=['src', 'include'],
+            extra_compile_args=['-fPIC', '-O2', '-Wall', 
+                                '-DSUPPORT_64BIT_OFFSET', 
+                                '-DDISTORM_STATIC']))]
+    else:
+        libraries = [(
+            'distorm3', dict(
+            package='distorm3',
+            sources=get_sources,
+            include_dirs=['src', 'include'],
+            extra_compile_args=['-fPIC', '-O2', '-Wall', 
+                                '-DSUPPORT_64BIT_OFFSET', 
+                                '-DDISTORM_STATIC']))]
+    
+    options = {
+
+    # Setup instructions
+    'requires'          : ['ctypes'],
+    'provides'          : ['distorm3'],
+    'packages'          : ['distorm3'],
+    'package_dir'       : { '' : 'python' },
+    'cmdclass'          : { 'build' : custom_build,
+                            'build_clib' : custom_build_clib,
+                            'clean' : custom_clean, 
+                            'sdist' : custom_sdist },
+    'libraries'         : libraries,
+
+    # Metadata
+    'name'              : 'distorm3',
+    'version'           : '3.3.4',
+    'description'       : 'The goal of diStorm3 is to decode x86/AMD64' \
+                          ' binary streams and return a structure that' \
+                          ' describes each instruction.',
+    'long_description'  : (
+                        'Powerful Disassembler Library For AMD64\n'
+                        'by Gil Dabah (distorm@gmail.com)\n'
+                        '\n'
+                        'Python bindings by Mario Vilas (mvilas@gmail.com)'
+                        ),
+    'author'            : 'Gil Dabah',
+    'author_email'      : 'distorm'+chr(64)+'gmail'+chr(0x2e)+'com',
+    'maintainer'        : 'Gil Dabah',
+    'maintainer_email'  : 'distorm'+chr(64)+'gmail'+chr(0x2e)+'com',
+    'url'               : 'https://github.com/gdabah/distorm/',
+    'download_url'      : 'https://github.com/gdabah/distorm/',
+    'platforms'         : ['cygwin', 'win', 'linux', 'macosx'],
+    'classifiers'       : [
+                        'License :: OSI Approved :: BSD License',
+                        'Development Status :: 5 - Production/Stable',
+                        'Intended Audience :: Developers',
+                        'Natural Language :: English',
+                        'Operating System :: Microsoft :: Windows',
+                        'Operating System :: MacOS :: MacOS X',
+                        'Operating System :: POSIX :: Linux',
+                        'Programming Language :: Python :: 2.7',
+                        'Programming Language :: Python :: 3.5',
+                        'Topic :: Software Development :: Disassemblers',
+                        'Topic :: Software Development :: Libraries :: Python Modules',
+                        ]
+    }
+
+    # Call the setup function
+    setup(**options)
+
+if __name__ == '__main__':
+    main()

data/funchook/distorm/src/config.h

@@ -0,0 +1,169 @@
+/*
+config.h
+
+diStorm3 - Powerful disassembler for X86/AMD64
+http://ragestorm.net/distorm/
+distorm at gmail dot com
+Copyright (C) 2003-2016 Gil Dabah
+This library is licensed under the BSD license. See the file COPYING.
+*/
+
+
+#ifndef CONFIG_H
+#define CONFIG_H
+
+/* diStorm version number. */
+#define __DISTORMV__ 0x030304
+
+#include <string.h> /* memset, memcpy - can be easily self implemented for libc independency. */
+
+#include "../include/distorm.h"
+
+
+/*
+ * 64 bit offsets support:
+ * This macro should be defined from compiler command line flags, e.g: -DSUPPORT_64BIT_OFFSET
+ * Note: make sure that the caller (library user) defines it too!
+ */
+/* #define SUPPORT_64BIT_OFFSET */
+
+/*
+ * If you compile diStorm as a dynamic library (.dll or .so) file, make sure you uncomment the next line.
+ * So the interface functions will be exported, otherwise they are useable only for static library.
+ * For example, this macro is being set for compiling diStorm as a .dll for Python with CTypes.
+ */
+/* #define DISTORM_DYNAMIC */
+
+/*
+ * If DISTORM_LIGHT is defined, everything involved in formatting the instructions
+ * as text will be excluded from compilation.
+ * distorm_decode(..) and distorm_format(..) will not be available.
+ * This will decrease the size of the executable and leave you with decomposition functionality only.
+ *
+ * Note: it should be either set in the preprocessor definitions manually or in command line -D switch.
+ * #define DISTORM_LIGHT
+ */
+
+/*
+ * diStorm now supports little/big endian CPU's.
+ * It should detect the endianness according to predefined macro's of the compiler.
+ * If you don't use GCC/MSVC you will have to define it on your own.
+ */
+
+/* These macros are used in order to make the code portable. */
+#ifdef __GNUC__
+
+#include <stdint.h>
+
+#define _DLLEXPORT_
+#define _FASTCALL_
+#define _INLINE_ static
+/* GCC ignores this directive... */
+/*#define _FASTCALL_ __attribute__((__fastcall__))*/
+
+/* Set endianity (supposed to be LE though): */
+#ifdef __BIG_ENDIAN__
+	#define BE_SYSTEM
+#endif
+
+/* End of __GCC__ */
+
+#elif __WATCOMC__
+
+#include <stdint.h>
+
+#define _DLLEXPORT_
+#define _FASTCALL_
+#define _INLINE_ __inline
+
+/* End of __WATCOMC__ */
+
+#elif __DMC__
+
+#include <stdint.h>
+
+#define _DLLEXPORT_
+#define _FASTCALL_
+#define _INLINE_ __inline
+
+/* End of __DMC__ */
+
+#elif __TINYC__
+
+#include <stdint.h>
+
+#define _DLLEXPORT_
+#define _FASTCALL_
+#define _INLINE_
+
+/* End of __TINYC__ */
+
+#elif _MSC_VER
+
+/* stdint alternative is defined in distorm.h */
+
+#define _DLLEXPORT_ __declspec(dllexport)
+#define _FASTCALL_ __fastcall
+#define _INLINE_ __inline
+
+/* Set endianity (supposed to be LE though): */
+#if !defined(_M_IX86) && !defined(_M_X64)
+	#define BE_SYSTEM
+#endif
+
+#endif /* #elif _MSC_VER */
+
+/* If the library isn't compiled as a dynamic library don't export any functions. */
+#ifndef DISTORM_DYNAMIC
+#undef _DLLEXPORT_
+#define _DLLEXPORT_
+#endif
+
+#ifndef FALSE
+#define FALSE 0
+#endif
+#ifndef TRUE
+#define TRUE 1
+#endif
+
+/* Define stream read functions for big endian systems. */
+#ifdef BE_SYSTEM
+/*
+ * These functions can read from the stream safely!
+ * Swap endianity of input to little endian.
+ */
+static _INLINE_ int16_t RSHORT(const uint8_t *s)
+{
+	return s[0] | (s[1] << 8);
+}
+static _INLINE_ uint16_t RUSHORT(const uint8_t *s)
+{
+	return s[0] | (s[1] << 8);
+}
+static _INLINE_ int32_t RLONG(const uint8_t *s)
+{
+	return s[0] | (s[1] << 8) | (s[2] << 16) | (s[3] << 24);
+}
+static _INLINE_ uint32_t RULONG(const uint8_t *s)
+{
+	return s[0] | (s[1] << 8) | (s[2] << 16) | (s[3] << 24);
+}
+static _INLINE_ int64_t RLLONG(const uint8_t *s)
+{
+	return s[0] | (s[1] << 8) | (s[2] << 16) | (s[3] << 24) | ((uint64_t)s[4] << 32) | ((uint64_t)s[5] << 40) | ((uint64_t)s[6] << 48) | ((uint64_t)s[7] << 56);
+}
+static _INLINE_ uint64_t RULLONG(const uint8_t *s)
+{
+	return s[0] | (s[1] << 8) | (s[2] << 16) | (s[3] << 24) | ((uint64_t)s[4] << 32) | ((uint64_t)s[5] << 40) | ((uint64_t)s[6] << 48) | ((uint64_t)s[7] << 56);
+}
+#else
+/* Little endian macro's will just make the cast. */
+#define RSHORT(x) *(int16_t *)x
+#define RUSHORT(x) *(uint16_t *)x
+#define RLONG(x) *(int32_t *)x
+#define RULONG(x) *(uint32_t *)x
+#define RLLONG(x) *(int64_t *)x
+#define RULLONG(x) *(uint64_t *)x
+#endif
+
+#endif /* CONFIG_H */