home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_2251 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  9.0 KB  |  262 lines

  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. __revision__ = '$Id: RSA.py,v 1.20 2004/05/06 12:52:54 akuchling Exp $'
  5. from Crypto.PublicKey import pubkey
  6. from Crypto.Util import number
  7.  
  8. try:
  9.     from Crypto.PublicKey import _fastmath
  10. except ImportError:
  11.     _fastmath = None
  12.  
  13.  
  14. class error(Exception):
  15.     pass
  16.  
  17.  
  18. def generate(bits, randfunc, progress_func = None):
  19.     obj = RSAobj()
  20.     if progress_func:
  21.         progress_func('p,q\n')
  22.     
  23.     p = q = 0x1L
  24.     while number.size(p * q) < bits:
  25.         p = pubkey.getPrime(bits / 2, randfunc)
  26.         q = pubkey.getPrime(bits / 2, randfunc)
  27.     if p > q:
  28.         p = q
  29.         q = p
  30.     
  31.     obj.p = p
  32.     obj.q = q
  33.     if progress_func:
  34.         progress_func('u\n')
  35.     
  36.     obj.u = pubkey.inverse(obj.p, obj.q)
  37.     obj.n = obj.p * obj.q
  38.     obj.e = 0x10001L
  39.     if progress_func:
  40.         progress_func('d\n')
  41.     
  42.     obj.d = pubkey.inverse(obj.e, (obj.p - 1) * (obj.q - 1))
  43.     return obj
  44.  
  45.  
  46. def construct(tuple):
  47.     obj = RSAobj()
  48.     if len(tuple) not in (2, 3, 5, 6):
  49.         raise error, 'argument for construct() wrong length'
  50.     len(tuple) not in (2, 3, 5, 6)
  51.     for i in range(len(tuple)):
  52.         field = obj.keydata[i]
  53.         setattr(obj, field, tuple[i])
  54.     
  55.     if len(tuple) >= 5:
  56.         if obj.p > obj.q:
  57.             obj.p = obj.q
  58.             obj.q = obj.p
  59.         
  60.     
  61.     if len(tuple) == 5:
  62.         obj.u = pubkey.inverse(obj.p, obj.q)
  63.     
  64.     return obj
  65.  
  66.  
  67. class RSAobj(pubkey.pubkey):
  68.     keydata = [
  69.         'n',
  70.         'e',
  71.         'd',
  72.         'p',
  73.         'q',
  74.         'u']
  75.     
  76.     def _encrypt(self, plaintext, K = ''):
  77.         if self.n <= plaintext:
  78.             raise error, 'Plaintext too large'
  79.         self.n <= plaintext
  80.         return (pow(plaintext, self.e, self.n),)
  81.  
  82.     
  83.     def _decrypt(self, ciphertext):
  84.         if not hasattr(self, 'd'):
  85.             raise error, 'Private key not available in this object'
  86.         hasattr(self, 'd')
  87.         if self.n <= ciphertext[0]:
  88.             raise error, 'Ciphertext too large'
  89.         self.n <= ciphertext[0]
  90.         return pow(ciphertext[0], self.d, self.n)
  91.  
  92.     
  93.     def _sign(self, M, K = ''):
  94.         return (self._decrypt((M,)),)
  95.  
  96.     
  97.     def _verify(self, M, sig):
  98.         m2 = self._encrypt(sig[0])
  99.         if m2[0] == M:
  100.             return 1
  101.         return 0
  102.  
  103.     
  104.     def _blind(self, M, B):
  105.         tmp = pow(B, self.e, self.n)
  106.         return M * tmp % self.n
  107.  
  108.     
  109.     def _unblind(self, M, B):
  110.         tmp = pubkey.inverse(B, self.n)
  111.         return M * tmp % self.n
  112.  
  113.     
  114.     def can_blind(self):
  115.         return 1
  116.  
  117.     
  118.     def size(self):
  119.         return number.size(self.n) - 1
  120.  
  121.     
  122.     def has_private(self):
  123.         if hasattr(self, 'd'):
  124.             return 1
  125.         return 0
  126.  
  127.     
  128.     def publickey(self):
  129.         return construct((self.n, self.e))
  130.  
  131.  
  132.  
  133. class RSAobj_c(pubkey.pubkey):
  134.     keydata = [
  135.         'n',
  136.         'e',
  137.         'd',
  138.         'p',
  139.         'q',
  140.         'u']
  141.     
  142.     def __init__(self, key):
  143.         self.key = key
  144.  
  145.     
  146.     def __getattr__(self, attr):
  147.         if attr in self.keydata:
  148.             return getattr(self.key, attr)
  149.         if self.__dict__.has_key(attr):
  150.             self.__dict__[attr]
  151.         else:
  152.             raise AttributeError, '%s instance has no attribute %s' % (self.__class__, attr)
  153.         return attr in self.keydata
  154.  
  155.     
  156.     def __getstate__(self):
  157.         d = { }
  158.         for k in self.keydata:
  159.             if hasattr(self.key, k):
  160.                 d[k] = getattr(self.key, k)
  161.                 continue
  162.         
  163.         return d
  164.  
  165.     
  166.     def __setstate__(self, state):
  167.         n = state['n']
  168.         e = state['e']
  169.         if not state.has_key('d'):
  170.             self.key = _fastmath.rsa_construct(n, e)
  171.         else:
  172.             d = state['d']
  173.             if not state.has_key('q'):
  174.                 self.key = _fastmath.rsa_construct(n, e, d)
  175.             else:
  176.                 p = state['p']
  177.                 q = state['q']
  178.                 u = state['u']
  179.                 self.key = _fastmath.rsa_construct(n, e, d, p, q, u)
  180.  
  181.     
  182.     def _encrypt(self, plain, K):
  183.         return (self.key._encrypt(plain),)
  184.  
  185.     
  186.     def _decrypt(self, cipher):
  187.         return self.key._decrypt(cipher[0])
  188.  
  189.     
  190.     def _sign(self, M, K):
  191.         return (self.key._sign(M),)
  192.  
  193.     
  194.     def _verify(self, M, sig):
  195.         return self.key._verify(M, sig[0])
  196.  
  197.     
  198.     def _blind(self, M, B):
  199.         return self.key._blind(M, B)
  200.  
  201.     
  202.     def _unblind(self, M, B):
  203.         return self.key._unblind(M, B)
  204.  
  205.     
  206.     def can_blind(self):
  207.         return 1
  208.  
  209.     
  210.     def size(self):
  211.         return self.key.size()
  212.  
  213.     
  214.     def has_private(self):
  215.         return self.key.has_private()
  216.  
  217.     
  218.     def publickey(self):
  219.         return construct_c((self.key.n, self.key.e))
  220.  
  221.  
  222.  
  223. def generate_c(bits, randfunc, progress_func = None):
  224.     if progress_func:
  225.         progress_func('p,q\n')
  226.     
  227.     p = q = 0x1L
  228.     while number.size(p * q) < bits:
  229.         p = pubkey.getPrime(bits / 2, randfunc)
  230.         q = pubkey.getPrime(bits / 2, randfunc)
  231.     if p > q:
  232.         p = q
  233.         q = p
  234.     
  235.     if progress_func:
  236.         progress_func('u\n')
  237.     
  238.     u = pubkey.inverse(p, q)
  239.     n = p * q
  240.     e = 0x10001L
  241.     if progress_func:
  242.         progress_func('d\n')
  243.     
  244.     d = pubkey.inverse(e, (p - 1) * (q - 1))
  245.     key = _fastmath.rsa_construct(n, e, d, p, q, u)
  246.     obj = RSAobj_c(key)
  247.     return obj
  248.  
  249.  
  250. def construct_c(tuple):
  251.     key = apply(_fastmath.rsa_construct, tuple)
  252.     return RSAobj_c(key)
  253.  
  254. object = RSAobj
  255. generate_py = generate
  256. construct_py = construct
  257. if _fastmath:
  258.     generate = generate_c
  259.     construct = construct_c
  260.     error = _fastmath.error
  261.  
  262.