home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 October / maximum-cd-2011-10.iso / DiscContents / digsby_setup.exe / lib / dns / entropy.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2011-06-22  |  3.4 KB  |  140 lines

  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.6)
  3.  
  4. import os
  5. import time
  6.  
  7. try:
  8.     import threading as _threading
  9. except ImportError:
  10.     import dummy_threading as _threading
  11.  
  12.  
  13. class EntropyPool(object):
  14.     
  15.     def __init__(self, seed = None):
  16.         self.pool_index = 0
  17.         self.digest = None
  18.         self.next_byte = 0
  19.         self.lock = _threading.Lock()
  20.         
  21.         try:
  22.             import hashlib
  23.             self.hash = hashlib.sha1()
  24.             self.hash_len = 20
  25.         except:
  26.             
  27.             try:
  28.                 import sha
  29.                 self.hash = sha.new()
  30.                 self.hash_len = 20
  31.             import md5
  32.             self.hash = md5.new()
  33.             self.hash_len = 16
  34.  
  35.  
  36.         self.pool = '\x00' * self.hash_len
  37.         if seed is not None:
  38.             self.stir(seed)
  39.             self.seeded = True
  40.         else:
  41.             self.seeded = False
  42.  
  43.     
  44.     def stir(self, entropy, already_locked = False):
  45.         if not already_locked:
  46.             self.lock.acquire()
  47.         
  48.         
  49.         try:
  50.             bytes = [ ord(c) for c in self.pool ]
  51.             for c in entropy:
  52.                 b = ord(c) & 255
  53.                 bytes[self.pool_index] ^= b
  54.                 self.pool_index += 1
  55.             
  56.             self.pool = []([ chr(c) for c in bytes ])
  57.         finally:
  58.             if not already_locked:
  59.                 self.lock.release()
  60.             
  61.  
  62.  
  63.     
  64.     def _maybe_seed(self):
  65.         if not self.seeded:
  66.             
  67.             try:
  68.                 seed = os.urandom(16)
  69.             except:
  70.                 
  71.                 try:
  72.                     r = file('/dev/urandom', 'r', 0)
  73.                     
  74.                     try:
  75.                         seed = r.read(16)
  76.                     finally:
  77.                         r.close()
  78.  
  79.                 seed = str(time.time())
  80.  
  81.  
  82.             self.seeded = True
  83.             self.stir(seed, True)
  84.         
  85.  
  86.     
  87.     def random_8(self):
  88.         self.lock.acquire()
  89.         self._maybe_seed()
  90.         
  91.         try:
  92.             if self.digest is None or self.next_byte == self.hash_len:
  93.                 self.hash.update(self.pool)
  94.                 self.digest = self.hash.digest()
  95.                 self.stir(self.digest, True)
  96.                 self.next_byte = 0
  97.             
  98.             value = ord(self.digest[self.next_byte])
  99.             self.next_byte += 1
  100.         finally:
  101.             self.lock.release()
  102.  
  103.         return value
  104.  
  105.     
  106.     def random_16(self):
  107.         return self.random_8() * 256 + self.random_8()
  108.  
  109.     
  110.     def random_32(self):
  111.         return self.random_16() * 65536 + self.random_16()
  112.  
  113.     
  114.     def random_between(self, first, last):
  115.         size = (last - first) + 1
  116.         if size > 0x100000000L:
  117.             raise ValueError('too big')
  118.         size > 0x100000000L
  119.         if size > 65536:
  120.             rand = self.random_32
  121.             max = 0xFFFFFFFFL
  122.         elif size > 256:
  123.             rand = self.random_16
  124.             max = 65535
  125.         else:
  126.             rand = self.random_8
  127.             max = 255
  128.         return first + size * rand() // (max + 1)
  129.  
  130.  
  131. pool = EntropyPool()
  132.  
  133. def random_16():
  134.     return pool.random_16()
  135.  
  136.  
  137. def between(first, last):
  138.     return pool.random_between(first, last)
  139.  
  140.