diff --git a/doc/source/tutorial/weave.rst b/doc/source/tutorial/weave.rst
index 12cff19..7a481db 100644
--- a/doc/source/tutorial/weave.rst
+++ b/doc/source/tutorial/weave.rst
@@ -885,11 +885,11 @@ Microsoft VC++ installed.
 When ``inline`` is first run, you'll notice that pause and some trash printed
 to the screen. The "trash" is acutually part of the compilers output that
 distutils does not supress. The name of the extension file,
-``sc_bighonkingnumber.cpp``, is generated from the md5 check sum of the C/C++
-code fragment. On Unix or windows machines with only gcc installed, the trash
-will not appear. On the second call, the code fragment is not compiled since
-it already exists, and only the answer is returned. Now kill the interpreter
-and restart, and run the same code with a different string.
+``sc_bighonkingnumber.cpp``, is generated from the SHA-256 check sum of the
+C/C++ code fragment. On Unix or windows machines with only gcc installed, the
+trash will not appear. On the second call, the code fragment is not compiled
+since it already exists, and only the answer is returned. Now kill the
+interpreter and restart, and run the same code with a different string.
 
 ::
 
@@ -1151,8 +1151,8 @@ A quick look at the code
 ------------------------
 
 ``weave`` generates a C++ file holding an extension function for each
-``inline`` code snippet. These file names are generated using from the md5
-signature of the code snippet and saved to a location specified by the
+``inline`` code snippet. These file names are generated using from the
+SHA-256 signature of the code snippet and saved to a location specified by the
 PYTHONCOMPILED environment variable (discussed later). The cpp files are
 generally about 200-400 lines long and include quite a few functions to
 support type conversions, etc. However, the actual compiled function is
@@ -2401,10 +2401,10 @@ been built before.
 
 .. note::
   If we were willing to always pay the penalty of building the C++
-  code for a module, we could store the md5 checksum of the C++ code
+  code for a module, we could store the SHA-256 checksum of the C++ code
   along with some information about the compiler, platform, etc. Then,
   ``ext_module.compile()`` could try importing the module before it
-  actually compiles it, check the md5 checksum and other meta-data in
+  actually compiles it, check the SHA-256 checksum and other meta-data in
   the imported module with the meta-data of the code it just produced
   and only compile the code if the module didn't exist or the
   meta-data didn't match. This would reduce the above code to::
diff --git a/scipy/weave/accelerate_tools.py b/scipy/weave/accelerate_tools.py
index 935ca23..1627447 100644
--- a/scipy/weave/accelerate_tools.py
+++ b/scipy/weave/accelerate_tools.py
@@ -12,7 +12,7 @@ from __future__ import absolute_import, print_function
 
 from types import InstanceType, XRangeType
 import inspect
-import scipy.weave.md5_load as md5
+from hashlib import sha256
 import scipy.weave as weave
 from numpy.testing import assert_
 
@@ -342,7 +342,7 @@ class accelerate(object):
         return fast
 
     def identifier(self,signature):
-        # Build an MD5 checksum
+        # Build a SHA-256 checksum
         f = self.function
         co = f.func_code
         identifier = str(signature)+\
@@ -350,7 +350,7 @@ class accelerate(object):
                      str(co.co_consts)+\
                      str(co.co_varnames)+\
                      co.co_code
-        return 'F'+md5.md5(identifier).hexdigest()
+        return 'F' + sha256(identifier).hexdigest()
 
     def accelerate(self,signature,identifier):
         P = Python2CXX(self.function,signature,name=identifier)
diff --git a/scipy/weave/build_tools.py b/scipy/weave/build_tools.py
index c0f8baa..27d27a4 100644
--- a/scipy/weave/build_tools.py
+++ b/scipy/weave/build_tools.py
@@ -234,7 +234,7 @@ def build_extension(module_path,compiler_name = '',build_dir = None,
     # dag. We keep having to add directories to the path to keep
     # object files separated from each other.  gcc2.x and gcc3.x C++
     # object files are not compatible, so we'll stick them in a sub
-    # dir based on their version.  This will add an md5 check sum
+    # dir based on their version. This will add a SHA-256 check sum
     # of the compiler binary to the directory name to keep objects
     # from different compilers in different locations.
 
diff --git a/scipy/weave/catalog.py b/scipy/weave/catalog.py
index 274ed41..bb15f26 100644
--- a/scipy/weave/catalog.py
+++ b/scipy/weave/catalog.py
@@ -84,13 +84,13 @@ def getmodule(object):
 def expr_to_filename(expr):
     """ Convert an arbitrary expr string to a valid file name.
 
-        The name is based on the md5 check sum for the string and
+        The name is based on the SHA-256 check sum for the string and
         Something that was a little more human readable would be
         nice, but the computer doesn't seem to care.
     """
-    import scipy.weave.md5_load as md5
+    from hashlib import sha256
     base = 'sc_'
-    return base + md5.new(expr).hexdigest()
+    return base + sha256(expr).hexdigest()
 
 def unique_file(d,expr):
     """ Generate a unqiue file name based on expr in directory d
diff --git a/scipy/weave/md5_load.py b/scipy/weave/md5_load.py
deleted file mode 100644
index 80594ad..0000000
--- a/scipy/weave/md5_load.py
+++ /dev/null
@@ -1,11 +0,0 @@
-# Import correct md5, irrespective of the Python version
-#
-# `hashlib` was introduced in 2.5, deprecating `md5`
-from __future__ import absolute_import, print_function
-
-try:
-    from hashlib import *
-except ImportError:
-    from md5 import *
-
-new = md5
diff --git a/scipy/weave/platform_info.py b/scipy/weave/platform_info.py
index df67ca5..f7d7490 100644
--- a/scipy/weave/platform_info.py
+++ b/scipy/weave/platform_info.py
@@ -89,13 +89,13 @@ def compiler_exe_path(exe_name):
     return exe_path
 
 def check_sum(file):
-    import scipy.weave.md5_load as md5
+    from hashlib import sha256
     try:
         f = open(file,'r')
         bytes = f.read(-1)
     except IOError:
         bytes = ''
-    chk_sum = md5.md5(bytes)
+    chk_sum = sha256(bytes)
     return chk_sum.hexdigest()
 
 def get_compiler_dir(compiler_name):