setup.py

#! /usr/bin/env python
#
#  setup.py : Distutils setup script
#
#  Part of the Python Cryptography Toolkit
#
# ===================================================================
# Portions Copyright (c) 2001, 2002, 2003 Python Software Foundation;
# All Rights Reserved
#
# This file contains code from the Python 2.2 setup.py module (the
# "Original Code"), with modifications made after it was incorporated
# into PyCrypto (the "Modifications").
#
# To the best of our knowledge, the Python Software Foundation is the
# copyright holder of the Original Code, and has licensed it under the
# Python 2.2 license.  See the file LEGAL/copy/LICENSE.python-2.2 for
# details.
#
# The Modifications to this file are dedicated to the public domain.
# To the extent that dedication to the public domain is not available,
# everyone is granted a worldwide, perpetual, royalty-free,
# non-exclusive license to exercise all rights associated with the
# contents of this file for any purpose whatsoever.  No rights are
# reserved.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
# ===================================================================

__revision__ = "$Id$"

from distutils import core
from distutils.ccompiler import new_compiler
from distutils.core import Extension, Command
from distutils.command.build import build
from distutils.command.build_ext import build_ext
import distutils.sysconfig
import os, sys, re
import struct

if sys.version[0:1] == '1':
    raise RuntimeError ("The Python Cryptography Toolkit requires "
                         "Python 2.x or 3.x to build.")

if sys.platform == 'win32':
    HTONS_LIBS = ['ws2_32']
    plat_ext = [
                Extension("Crypto.Random.OSRNG.winrandom",
                          libraries = HTONS_LIBS + ['advapi32'],
                          include_dirs=['src/'],
                          sources=["src/winrand.c"])
               ]
else:
    HTONS_LIBS = []
    plat_ext = []

# For test development: Set this to 1 to build with gcov support.
# Use "gcov -p -o build/temp.*/src build/temp.*/src/*.gcda" to build the
# .gcov files
USE_GCOV = 0


try:
    # Python 3
    from distutils.command.build_py import build_py_2to3 as build_py
except ImportError:
    # Python 2
    from distutils.command.build_py import build_py

# List of pure Python modules that will be excluded from the binary packages.
# The list consists of (package, module_name) tuples
if sys.version_info[0] == 2:
    EXCLUDE_PY = []
else:
    EXCLUDE_PY = [
        # We don't want Py3k to choke on the 2.x compat code
        ('Crypto.Util', 'py21compat'), 
    ]
    if sys.platform != "win32": # Avoid nt.py, as 2to3 can't fix it w/o winrandom
        EXCLUDE_PY += [('Crypto.Random.OSRNG','nt')]

# Work around the print / print() issue with Python 2.x and 3.x. We only need
# to print at one point of the code, which makes this easy

def PrintErr(*args, **kwd):
    fout = kwd.get("file", sys.stderr)
    w = fout.write
    if args:
        w(str(args[0]))
        sep = kwd.get("sep", " ")
        for a in args[1:]:
            w(sep)
            w(str(a))
        w(kwd.get("end", "\n"))

def endianness_macro():
    s = struct.pack("@I", 0x33221100)
    if s == "\x00\x11\x22\x33".encode():     # little endian
        return ('PCT_LITTLE_ENDIAN', 1)
    elif s == "\x33\x22\x11\x00".encode():   # big endian
        return ('PCT_BIG_ENDIAN', 1)
    raise AssertionError("Machine is neither little-endian nor big-endian")

class PCTBuildExt (build_ext):
    def build_extensions(self):
        # Detect which modules should be compiled
        self.detect_modules()

        # Tweak compiler options
        if self.compiler.compiler_type in ('unix', 'cygwin', 'mingw32'):
            # Make assert() statements always work
            self.__remove_compiler_option("-DNDEBUG")

            if USE_GCOV:    # TODO - move this to configure.ac
                self.__add_compiler_option("-fprofile-arcs")
                self.__add_compiler_option("-ftest-coverage")
                self.compiler.libraries += ['gcov']

            # Python 2.1 and 2.2 don't respect the LDFLAGS environment variable.  Hack it.
            if sys.version_info < (2, 3, 'final', 0):
                if os.environ.get('LDFLAGS'):       # Set from ./buildenv (ultimately provided by autoconf)
                    for opt in os.environ['LDFLAGS'].split(" "):
                        opt = opt.strip()
                        if not opt: continue
                        self.compiler.linker_so.append(opt)

        # Call the superclass's build_extensions method
        build_ext.build_extensions(self)

    def detect_modules (self):
        # Read the config.h file (usually generated by autoconf)
        if self.compiler.compiler_type == 'msvc':
            # Add special include directory for MSVC (because MSVC is special)
            self.compiler.include_dirs.insert(0, "src/inc-msvc/")
            ac = self.__read_autoconf("src/inc-msvc/config.h")
        else:
            ac = self.__read_autoconf("src/config.h")

        # Detect libgmp or libmpir and don't build _fastmath if both are missing.
        if ac.get("HAVE_LIBGMP"):
            # Default; no changes needed
            pass
        elif ac.get("HAVE_LIBMPIR"):
            # Change library to libmpir if libgmp is missing
            self.__change_extension_lib(["Crypto.PublicKey._fastmath"],
                ['mpir'])
            # And if this is MSVC, we need to add a linker option
            # to make a static libmpir link well into a dynamic _fastmath
            if self.compiler.compiler_type == 'msvc':
                self.__add_extension_link_option(["Crypto.PublicKey._fastmath"],
                    ["/NODEFAULTLIB:LIBCMT"])
        else:
            # No MP library; use _slowmath.
            PrintErr ("warning: GMP or MPIR library not found; Not building "+
                "Crypto.PublicKey._fastmath.")
            self.__remove_extensions(["Crypto.PublicKey._fastmath"])

        # Detect if we have AES-NI instrincs available
        if not ac.get("HAVE_WMMINTRIN_H"):
            # AES-NI instrincs not available
            self.__remove_extensions(["Crypto.Cipher._AESNI"])
        elif ac.get("HAVE_MAES"):
            # -maes has to be passed to the compiler to use the AES-NI instrincs
            self.__add_extension_compile_option(["Crypto.Cipher._AESNI"],
                                                ["-maes"])

    def __add_extension_compile_option(self, names, options):
        """Add compiler options for the specified extension(s)"""
        for extension in self.extensions:
            if extension.name in names:
                extension.extra_compile_args = options

    def __add_extension_link_option(self, names, options):
        """Add linker options for the specified extension(s)"""
        i = 0
        while i < len(self.extensions):
            if self.extensions[i].name in names:
                self.extensions[i].extra_link_args = options
            i += 1

    def __change_extension_lib(self, names, libs):
        """Change the libraries to be used for the specified extension(s)"""
        i = 0
        while i < len(self.extensions):
           if self.extensions[i].name in names:
                self.extensions[i].libraries = libs
           i += 1

    def __remove_extensions(self, names):
        """Remove the specified extension(s) from the list of extensions
       to build"""
        i = 0
        while i < len(self.extensions):
            if self.extensions[i].name in names:
                del self.extensions[i]
                continue
            i += 1

    def __remove_compiler_option(self, option):
        """Remove the specified compiler option.

        Return true if the option was found.  Return false otherwise.
        """
        found = 0
        for attrname in ('compiler', 'compiler_so'):
            compiler = getattr(self.compiler, attrname, None)
            if compiler is not None:
                while option in compiler:
                    compiler.remove(option)
                    found += 1
        return found

    def __add_compiler_option(self, option):
        for attrname in ('compiler', 'compiler_so'):
            compiler = getattr(self.compiler, attrname, None)
            if compiler is not None:
                compiler.append(option)

    def __read_autoconf(self, filename):
        rx_define = re.compile(r"""^#define (\S+) (?:(\d+)|(".*"))$""")

        result = {}
        f = open(filename, "r")
        try:
            config_lines = f.read().replace("\r\n", "\n").split("\n")
            for line in config_lines:
                m = rx_define.search(line)
                if not m: continue
                sym = m.group(1)
                n = m.group(2)
                s = m.group(3)
                if n:
                    result[sym] = int(n)
                elif s:
                    result[sym] = eval(s)     # XXX - hack to unescape C-style string
                else:
                    continue
        finally:
            f.close()
        return result

    def run(self):
        # Run the commands that this one depends on (i.e. build_configure)
        for cmd_name in self.get_sub_commands():
            self.run_command(cmd_name)

        class unmodified: pass      # sentinel value
        orig_cc = unmodified
        try:
            # Set environment variables generated by the configure script
            if os.path.exists("buildenv"):
                try:
                    f = open("buildenv", "r")
                    for line in f.readlines():
                        if line.startswith("#") or not line.strip():
                            continue
                        k, v = line.split("=", 1)
                        k, v = k.strip(), v.strip()
                        os.environ[k] = v
                finally:
                    f.close()

                # Python 2.1 and 2.2 don't respect the CC environment variable by default.  Monkey-patch it.
                if sys.version_info < (2, 3, 'final', 0) and os.environ.get('CC'):
                    distutils.sysconfig.get_config_vars()   # populates distutils.sysconfig._config_vars
                    orig_cc = distutils.sysconfig._config_vars['CC']
                    distutils.sysconfig._config_vars['CC'] = os.environ['CC']

            # Build the extension modules
            build_ext.run(self)

        finally:
            if orig_cc is not unmodified:
                # Undo monkey-patch
                distutils.sysconfig._config_vars['CC'] = orig_cc


    def has_configure(self):
        compiler = new_compiler(compiler=self.compiler)
        return compiler.compiler_type != 'msvc'

    sub_commands = [ ('build_configure', has_configure) ] + build_ext.sub_commands

class PCTBuildConfigure(Command):
    description = "Generate config.h using ./configure (autoconf)"

    def initialize_options(self):
        pass

    def finalize_options(self):
        pass

    def run(self):
        if not os.path.exists("config.status"):
            if hasattr(os, "chmod"):
                import stat
                os.chmod("configure", stat.S_IRUSR | stat.S_IWUSR |
                         stat.S_IXUSR | stat.S_IRGRP | stat.S_IXGRP |
                         stat.S_IROTH | stat.S_IXOTH)
            cmd = "sh configure"    # we use "sh" here so that it'll work on mingw32 with standard python.org binaries
            if self.verbose < 1:
                cmd += " -q"
            if os.system(cmd) != 0:
                raise RuntimeError("autoconf error")

class PCTBuildPy(build_py):
    def find_package_modules(self, package, package_dir, *args, **kwargs):
        modules = build_py.find_package_modules(self, package, package_dir,
            *args, **kwargs)

        # Exclude certain modules
        retval = []
        for item in modules:
            pkg, module = item[:2]
            if (pkg, module) in EXCLUDE_PY:
                continue
            retval.append(item)
        return retval


class TestCommand(Command):

    description = "Run self-test"

    # Long option name, short option name, description
    user_options = [
        ('skip-slow-tests', None,
            'Skip slow tests'),
        ('module=', 'm', 'Test a single module (e.g. Cipher, PublicKey)')
    ]

    def initialize_options(self):
        self.build_dir = None
        self.skip_slow_tests = None
        self.module = None

    def finalize_options(self):
        self.set_undefined_options('install', ('build_lib', 'build_dir'))
        self.config = {'slow_tests': not self.skip_slow_tests}

    def run(self):
        # Run sub commands
        for cmd_name in self.get_sub_commands():
            self.run_command(cmd_name)

        # Run SelfTest
        self.announce("running self-tests")
        old_path = sys.path[:]
        try:
            sys.path.insert(0, self.build_dir)
            from Crypto import SelfTest
            moduleObj = None
            if self.module:
                if self.module.count('.')==0:
                    # Test a whole a sub-package
                    full_module = "Crypto.SelfTest." + self.module
                    module_name = self.module
                else:
                    # Test only a module
                    # Assume only one dot is present
                    comps = self.module.split('.')
                    module_name = "test_" + comps[1]
                    full_module = "Crypto.SelfTest." + comps[0] + "." + module_name
                # Import sub-package or module
                moduleObj = __import__( full_module, globals(), locals(), module_name )
            SelfTest.run(module=moduleObj, verbosity=self.verbose, stream=sys.stdout, config=self.config)
        finally:
            # Restore sys.path
            sys.path[:] = old_path

        # Run slower self-tests
        self.announce("running extended self-tests")

    sub_commands = [ ('build', None) ]

kw = {'name':"pycrypto",
      'version':"2.7a1",  # See also: lib/Crypto/__init__.py
      'description':"Cryptographic modules for Python.",
      'author':"Dwayne C. Litzenberger",
      'author_email':"dlitz@dlitz.net",
      'url':"http://www.pycrypto.org/",

      'cmdclass' : {'build_configure': PCTBuildConfigure, 'build_ext': PCTBuildExt, 'build_py': PCTBuildPy, 'test': TestCommand },
      'packages' : ["Crypto", "Crypto.Hash", "Crypto.Cipher", "Crypto.Util",
                  "Crypto.Random",
                  "Crypto.Random.Fortuna",
                  "Crypto.Random.OSRNG",
                  "Crypto.SelfTest",
                  "Crypto.SelfTest.Cipher",
                  "Crypto.SelfTest.Hash",
                  "Crypto.SelfTest.Protocol",
                  "Crypto.SelfTest.PublicKey",
                  "Crypto.SelfTest.Random",
                  "Crypto.SelfTest.Random.Fortuna",
                  "Crypto.SelfTest.Random.OSRNG",
                  "Crypto.SelfTest.Util",
                  "Crypto.SelfTest.Signature",
                  "Crypto.SelfTest.IO",
                  "Crypto.Protocol",
                  "Crypto.PublicKey",
                  "Crypto.Signature",
                  "Crypto.IO"],
      'package_dir' : { "Crypto": "lib/Crypto" },
      'ext_modules': plat_ext + [
            # _fastmath (uses GNU mp library)
            Extension("Crypto.PublicKey._fastmath",
                      include_dirs=['src/'],
                      libraries=['gmp'],
                      sources=["src/_fastmath.c"]),

            # Hash functions
            Extension("Crypto.Hash.MD2",
                      include_dirs=['src/'],
                      sources=["src/MD2.c"]),
            Extension("Crypto.Hash.MD4",
                      include_dirs=['src/'],
                      sources=["src/MD4.c"]),
            Extension("Crypto.Hash.SHA256",
                      include_dirs=['src/'],
                      sources=["src/SHA256.c"]),
            Extension("Crypto.Hash.SHA224",
                      include_dirs=['src/'],
                      sources=["src/SHA224.c"]),
            Extension("Crypto.Hash.SHA384",
                      include_dirs=['src/'],
                      sources=["src/SHA384.c"]),
            Extension("Crypto.Hash.SHA512",
                      include_dirs=['src/'],
                      sources=["src/SHA512.c"]),
            Extension("Crypto.Hash.RIPEMD160",
                      include_dirs=['src/'],
                      sources=["src/RIPEMD160.c"],
                      define_macros=[endianness_macro()]),

            # Block encryption algorithms
            Extension("Crypto.Cipher._AES",
                      include_dirs=['src/'],
                      sources=["src/AES.c"]),
            Extension("Crypto.Cipher._AESNI",
                      include_dirs=['src/'],
                      sources=["src/AESNI.c"]),
            Extension("Crypto.Cipher._ARC2",
                      include_dirs=['src/'],
                      sources=["src/ARC2.c"]),
            Extension("Crypto.Cipher._Blowfish",
                      include_dirs=['src/'],
                      sources=["src/Blowfish.c"]),
            Extension("Crypto.Cipher._CAST",
                      include_dirs=['src/'],
                      sources=["src/CAST.c"]),
            Extension("Crypto.Cipher._DES",
                      include_dirs=['src/', 'src/libtom/'],
                      sources=["src/DES.c"]),
            Extension("Crypto.Cipher._DES3",
                      include_dirs=['src/', 'src/libtom/'],
                      sources=["src/DES3.c"]),

            # Stream ciphers
            Extension("Crypto.Cipher._ARC4",
                      include_dirs=['src/'],
                      sources=["src/ARC4.c"]),
            Extension("Crypto.Cipher._XOR",
                      include_dirs=['src/'],
                      sources=["src/XOR.c"]),

            # Utility modules
            Extension("Crypto.Util.strxor",
                      include_dirs=['src/'],
                      sources=['src/strxor.c']),
            Extension("Crypto.Util.cpuid",
                      include_dirs=['src/'],
                      sources=['src/cpuid.c']),
            Extension("Crypto.Util.galois",
                      include_dirs=['src/'],
                      sources=['src/galois.c']),

            # Counter modules
            Extension("Crypto.Util._counter",
                      include_dirs=['src/'],
                      sources=['src/_counter.c']),
    ]
}

# If we're running Python 2.3, add extra information
if hasattr(core, 'setup_keywords'):
    if 'classifiers' in core.setup_keywords:
        kw['classifiers'] = [
          'Development Status :: 5 - Production/Stable',
          'License :: Public Domain',
          'Intended Audience :: Developers',
          'Operating System :: Unix',
          'Operating System :: Microsoft :: Windows',
          'Operating System :: MacOS :: MacOS X',
          'Topic :: Security :: Cryptography',
          'Programming Language :: Python :: 2',
          'Programming Language :: Python :: 3',
          ]

core.setup(**kw)

def touch(path):
    import os, time
    now = time.time()
    try:
        # assume it's there
        os.utime(path, (now, now))
    except os.error:
        PrintErr("Failed to update timestamp of "+path)

# PY3K: Workaround for winrandom.pyd not existing during the first pass.
# It needs to be there for 2to3 to fix the import in nt.py
if (sys.platform == 'win32' and sys.version_info[0] == 3 and
    'build' in sys.argv[1:]):
    PrintErr("\nSecond pass to allow 2to3 to fix nt.py. No cause for alarm.\n")
    touch("./lib/Crypto/Random/OSRNG/nt.py")
    core.setup(**kw)