home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_2247 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  9.4 KB  |  279 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. __revision__ = '$Id: DSA.py,v 1.16 2004/05/06 12:52:54 akuchling Exp $'
  5. from Crypto.PublicKey.pubkey import *
  6. from Crypto.Util import number
  7. from Crypto.Util.number import bytes_to_long, long_to_bytes
  8. from Crypto.Hash import SHA
  9.  
  10. try:
  11.     from Crypto.PublicKey import _fastmath
  12. except ImportError:
  13.     _fastmath = None
  14.  
  15.  
  16. class error(Exception):
  17.     pass
  18.  
  19.  
  20. def generateQ(randfunc):
  21.     S = randfunc(20)
  22.     hash1 = SHA.new(S).digest()
  23.     hash2 = SHA.new(long_to_bytes(bytes_to_long(S) + 1)).digest()
  24.     q = bignum(0)
  25.     for i in range(0, 20):
  26.         c = ord(hash1[i]) ^ ord(hash2[i])
  27.         if i == 0:
  28.             c = c | 128
  29.         
  30.         if i == 19:
  31.             c = c | 1
  32.         
  33.         q = q * 256 + c
  34.     
  35.     while not isPrime(q):
  36.         q = q + 2
  37.     if q < q:
  38.         pass
  39.     elif q < pow(2, 0xA0L):
  40.         return (S, q)
  41.     raise error, 'Bad q value generated'
  42.  
  43.  
  44. def generate(bits, randfunc, progress_func = None):
  45.     if bits < 160:
  46.         raise error, 'Key length <160 bits'
  47.     bits < 160
  48.     obj = DSAobj()
  49.     if progress_func:
  50.         progress_func('p,q\n')
  51.     
  52.     while None:
  53.         (S, obj.q) = generateQ(randfunc)
  54.         n = (bits - 1) / 160
  55.         C = 0
  56.         N = 2
  57.         V = { }
  58.         b = obj.q >> 5 & 15
  59.         powb = pow(bignum(2), b)
  60.         powL1 = pow(bignum(2), bits - 1)
  61.         while C < 4096:
  62.             for k in range(0, n + 1):
  63.                 V[k] = bytes_to_long(SHA.new(S + str(N) + str(k)).digest())
  64.             
  65.             W = V[n] % powb
  66.             for k in range(n - 1, -1, -1):
  67.                 W = (W << 0xA0L) + V[k]
  68.             
  69.             X = W + powL1
  70.             p = X - X % 2 * obj.q - 1
  71.             if powL1 <= p and isPrime(p):
  72.                 break
  73.             
  74.             C = C + 1
  75.             N = N + n + 1
  76.         if C < 4096:
  77.             break
  78.         
  79.         if progress_func:
  80.             progress_func('4096 multiples failed\n')
  81.             continue
  82.         continue
  83.         obj.p = p
  84.         power = (p - 1) / obj.q
  85.         if progress_func:
  86.             progress_func('h,g\n')
  87.         
  88.     while None:
  89.         h = bytes_to_long(randfunc(bits)) % (p - 1)
  90.         g = pow(h, power, p)
  91.         if h < h:
  92.             pass
  93.         elif h < p - 1 and g > 1:
  94.             break
  95.             continue
  96.         continue
  97.         obj.g = g
  98.         if progress_func:
  99.             progress_func('x,y\n')
  100.         
  101.     while None:
  102.         x = bytes_to_long(randfunc(20))
  103.         if x < x:
  104.             pass
  105.         elif x < obj.q:
  106.             break
  107.             continue
  108.         continue
  109.         obj.x = x
  110.         obj.y = pow(g, x, p)
  111.         return obj
  112.  
  113.  
  114. def construct(tuple):
  115.     obj = DSAobj()
  116.     if len(tuple) not in (4, 5):
  117.         raise error, 'argument for construct() wrong length'
  118.     len(tuple) not in (4, 5)
  119.     for i in range(len(tuple)):
  120.         field = obj.keydata[i]
  121.         setattr(obj, field, tuple[i])
  122.     
  123.     return obj
  124.  
  125.  
  126. class DSAobj(pubkey):
  127.     keydata = [
  128.         'y',
  129.         'g',
  130.         'p',
  131.         'q',
  132.         'x']
  133.     
  134.     def _encrypt(self, s, Kstr):
  135.         raise error, 'DSA algorithm cannot encrypt data'
  136.  
  137.     
  138.     def _decrypt(self, s):
  139.         raise error, 'DSA algorithm cannot decrypt data'
  140.  
  141.     
  142.     def _sign(self, M, K):
  143.         if K < 2 or self.q <= K:
  144.             raise error, 'K is not between 2 and q'
  145.         self.q <= K
  146.         r = pow(self.g, K, self.p) % self.q
  147.         s = inverse(K, self.q) * (M + self.x * r) % self.q
  148.         return (r, s)
  149.  
  150.     
  151.     def _verify(self, M, sig):
  152.         (r, s) = sig
  153.         if r <= 0 and r >= self.q and s <= 0 or s >= self.q:
  154.             return 0
  155.         w = inverse(s, self.q)
  156.         u1 = M * w % self.q
  157.         u2 = r * w % self.q
  158.         v1 = pow(self.g, u1, self.p)
  159.         v2 = pow(self.y, u2, self.p)
  160.         v = v1 * v2 % self.p
  161.         v = v % self.q
  162.         if v == r:
  163.             return 1
  164.         return 0
  165.  
  166.     
  167.     def size(self):
  168.         return number.size(self.p) - 1
  169.  
  170.     
  171.     def has_private(self):
  172.         if hasattr(self, 'x'):
  173.             return 1
  174.         return 0
  175.  
  176.     
  177.     def can_sign(self):
  178.         return 1
  179.  
  180.     
  181.     def can_encrypt(self):
  182.         return 0
  183.  
  184.     
  185.     def publickey(self):
  186.         return construct((self.y, self.g, self.p, self.q))
  187.  
  188.  
  189. object = DSAobj
  190. generate_py = generate
  191. construct_py = construct
  192.  
  193. class DSAobj_c(pubkey):
  194.     keydata = [
  195.         'y',
  196.         'g',
  197.         'p',
  198.         'q',
  199.         'x']
  200.     
  201.     def __init__(self, key):
  202.         self.key = key
  203.  
  204.     
  205.     def __getattr__(self, attr):
  206.         if attr in self.keydata:
  207.             return getattr(self.key, attr)
  208.         if self.__dict__.has_key(attr):
  209.             self.__dict__[attr]
  210.         else:
  211.             raise AttributeError, '%s instance has no attribute %s' % (self.__class__, attr)
  212.         return attr in self.keydata
  213.  
  214.     
  215.     def __getstate__(self):
  216.         d = { }
  217.         for k in self.keydata:
  218.             if hasattr(self.key, k):
  219.                 d[k] = getattr(self.key, k)
  220.                 continue
  221.         
  222.         return d
  223.  
  224.     
  225.     def __setstate__(self, state):
  226.         (y, g, p, q) = (state['y'], state['g'], state['p'], state['q'])
  227.         if not state.has_key('x'):
  228.             self.key = _fastmath.dsa_construct(y, g, p, q)
  229.         else:
  230.             x = state['x']
  231.             self.key = _fastmath.dsa_construct(y, g, p, q, x)
  232.  
  233.     
  234.     def _sign(self, M, K):
  235.         return self.key._sign(M, K)
  236.  
  237.     
  238.     def _verify(self, M, .2):
  239.         (r, s) = .2
  240.         return self.key._verify(M, r, s)
  241.  
  242.     
  243.     def size(self):
  244.         return self.key.size()
  245.  
  246.     
  247.     def has_private(self):
  248.         return self.key.has_private()
  249.  
  250.     
  251.     def publickey(self):
  252.         return construct_c((self.key.y, self.key.g, self.key.p, self.key.q))
  253.  
  254.     
  255.     def can_sign(self):
  256.         return 1
  257.  
  258.     
  259.     def can_encrypt(self):
  260.         return 0
  261.  
  262.  
  263.  
  264. def generate_c(bits, randfunc, progress_func = None):
  265.     obj = generate_py(bits, randfunc, progress_func)
  266.     (y, g, p, q, x) = (obj.y, obj.g, obj.p, obj.q, obj.x)
  267.     return construct_c((y, g, p, q, x))
  268.  
  269.  
  270. def construct_c(tuple):
  271.     key = apply(_fastmath.dsa_construct, tuple)
  272.     return DSAobj_c(key)
  273.  
  274. if _fastmath:
  275.     generate = generate_c
  276.     construct = construct_c
  277.     error = _fastmath.error
  278.  
  279.