Update dnspython-2.2.0

lib/dns/entropy.py

@@ -1,4 +1,6 @@
-# Copyright (C) 2009, 2011 Nominum, Inc.
+# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
+
+# Copyright (C) 2009-2017 Nominum, Inc.
 #
 # Permission to use, copy, modify, and distribute this software and its
 # documentation for any purpose with or without fee is hereby granted,
@@ -14,85 +16,76 @@
 # OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
 import os
+import hashlib
+import random
 import time
-from ._compat import long, binary_type
 try:
     import threading as _threading
-except ImportError:
-    import dummy_threading as _threading
+except ImportError:  # pragma: no cover
+    import dummy_threading as _threading    # type: ignore
 
 
-class EntropyPool(object):
+class EntropyPool:
+
+    # This is an entropy pool for Python implementations that do not
+    # have a working SystemRandom.  I'm not sure there are any, but
+    # leaving this code doesn't hurt anything as the library code
+    # is used if present.
 
     def __init__(self, seed=None):
         self.pool_index = 0
         self.digest = None
         self.next_byte = 0
         self.lock = _threading.Lock()
-        try:
-            import hashlib
-            self.hash = hashlib.sha1()
-            self.hash_len = 20
-        except:
-            try:
-                import sha
-                self.hash = sha.new()
-                self.hash_len = 20
-            except:
-                import md5
-                self.hash = md5.new()
-                self.hash_len = 16
+        self.hash = hashlib.sha1()
+        self.hash_len = 20
         self.pool = bytearray(b'\0' * self.hash_len)
         if seed is not None:
-            self.stir(bytearray(seed))
+            self._stir(bytearray(seed))
             self.seeded = True
+            self.seed_pid = os.getpid()
         else:
             self.seeded = False
+            self.seed_pid = 0
 
-    def stir(self, entropy, already_locked=False):
-        if not already_locked:
-            self.lock.acquire()
-        try:
-            for c in entropy:
-                if self.pool_index == self.hash_len:
-                    self.pool_index = 0
-                b = c & 0xff
-                self.pool[self.pool_index] ^= b
-                self.pool_index += 1
-        finally:
-            if not already_locked:
-                self.lock.release()
+    def _stir(self, entropy):
+        for c in entropy:
+            if self.pool_index == self.hash_len:
+                self.pool_index = 0
+            b = c & 0xff
+            self.pool[self.pool_index] ^= b
+            self.pool_index += 1
+
+    def stir(self, entropy):
+        with self.lock:
+            self._stir(entropy)
 
     def _maybe_seed(self):
-        if not self.seeded:
+        if not self.seeded or self.seed_pid != os.getpid():
             try:
                 seed = os.urandom(16)
-            except:
+            except Exception:  # pragma: no cover
                 try:
-                    r = open('/dev/urandom', 'rb', 0)
-                    try:
+                    with open('/dev/urandom', 'rb', 0) as r:
                         seed = r.read(16)
-                    finally:
-                        r.close()
-                except:
+                except Exception:
                     seed = str(time.time())
             self.seeded = True
+            self.seed_pid = os.getpid()
+            self.digest = None
             seed = bytearray(seed)
-            self.stir(seed, True)
+            self._stir(seed)
 
     def random_8(self):
-        self.lock.acquire()
-        try:
+        with self.lock:
             self._maybe_seed()
             if self.digest is None or self.next_byte == self.hash_len:
-                self.hash.update(binary_type(self.pool))
+                self.hash.update(bytes(self.pool))
                 self.digest = bytearray(self.hash.digest())
-                self.stir(self.digest, True)
+                self._stir(self.digest)
                 self.next_byte = 0
             value = self.digest[self.next_byte]
             self.next_byte += 1
-        finally:
-            self.lock.release()
         return value
 
     def random_16(self):
@@ -103,25 +96,34 @@ class EntropyPool(object):
 
     def random_between(self, first, last):
         size = last - first + 1
-        if size > long(4294967296):
+        if size > 4294967296:
             raise ValueError('too big')
         if size > 65536:
             rand = self.random_32
-            max = long(4294967295)
+            max = 4294967295
         elif size > 256:
             rand = self.random_16
             max = 65535
         else:
             rand = self.random_8
             max = 255
-        return (first + size * rand() // (max + 1))
+        return first + size * rand() // (max + 1)
 
 pool = EntropyPool()
 
+try:
+    system_random = random.SystemRandom()
+except Exception:  # pragma: no cover
+    system_random = None
 
 def random_16():
-    return pool.random_16()
-
+    if system_random is not None:
+        return system_random.randrange(0, 65536)
+    else:
+        return pool.random_16()
 
 def between(first, last):
-    return pool.random_between(first, last)
+    if system_random is not None:
+        return system_random.randrange(first, last + 1)
+    else:
+        return pool.random_between(first, last)