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

  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. __license__ = 'GPL v3'
  5. __copyright__ = '2008, Marshall T. Vandegrift <llasram@gmail.com>'
  6. import struct
  7. import copy
  8.  
  9. def _long2bytesBigEndian(n, blocksize = 0):
  10.     s = ''
  11.     pack = struct.pack
  12.     while n > 0:
  13.         s = pack('>I', n & 0xFFFFFFFFL) + s
  14.         n = n >> 32
  15.     for i in range(len(s)):
  16.         if s[i] != '\x00':
  17.             break
  18.             continue
  19.     else:
  20.         s = '\x00'
  21.         i = 0
  22.     s = s[i:]
  23.     if blocksize > 0 and len(s) % blocksize:
  24.         s = (blocksize - len(s) % blocksize) * '\x00' + s
  25.     
  26.     return s
  27.  
  28.  
  29. def _bytelist2longBigEndian(list):
  30.     imax = len(list) / 4
  31.     hl = [
  32.         0x0L] * imax
  33.     j = 0
  34.     i = 0
  35.     while i < imax:
  36.         b0 = long(ord(list[j])) << 24
  37.         b1 = long(ord(list[j + 1])) << 16
  38.         b2 = long(ord(list[j + 2])) << 8
  39.         b3 = long(ord(list[j + 3]))
  40.         hl[i] = b0 | b1 | b2 | b3
  41.         i = i + 1
  42.         j = j + 4
  43.     return hl
  44.  
  45.  
  46. def _rotateLeft(x, n):
  47.     return x << n | x >> 32 - n
  48.  
  49.  
  50. def f0_19(B, C, D):
  51.     return B & (C ^ D) ^ D
  52.  
  53.  
  54. def f20_39(B, C, D):
  55.     return B ^ C ^ D
  56.  
  57.  
  58. def f40_59(B, C, D):
  59.     return (B | C) & D | B & C
  60.  
  61.  
  62. def f60_79(B, C, D):
  63.     return B ^ C ^ D
  64.  
  65.  
  66. def f6_42(B, C, D):
  67.     return B + C ^ C
  68.  
  69. f = [
  70.     f0_19] * 20 + [
  71.     f20_39] * 20 + [
  72.     f40_59] * 20 + [
  73.     f60_79] * 20
  74. f[3] = f20_39
  75. f[6] = f6_42
  76. f[10] = f20_39
  77. f[15] = f20_39
  78. f[26] = f0_19
  79. f[31] = f40_59
  80. f[42] = f6_42
  81. f[51] = f20_39
  82. f[68] = f0_19
  83. K = [
  84.     0x5A827999L,
  85.     0x6ED9EBA1L,
  86.     0x8F1BBCDCL,
  87.     0xCA62C1D6L]
  88.  
  89. class mssha1(object):
  90.     
  91.     def __init__(self):
  92.         self.length = 0x0L
  93.         self.count = [
  94.             0,
  95.             0]
  96.         self.input = []
  97.         self.init()
  98.  
  99.     
  100.     def init(self):
  101.         self.length = 0x0L
  102.         self.input = []
  103.         self.H0 = 0x32107654L
  104.         self.H1 = 0x23016745L
  105.         self.H2 = 0xC4E680A2L
  106.         self.H3 = 0xDC679823L
  107.         self.H4 = 0xD0857A34L
  108.  
  109.     
  110.     def _transform(self, W):
  111.         for t in range(16, 80):
  112.             W.append(_rotateLeft(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1) & 0xFFFFFFFFL)
  113.         
  114.         A = self.H0
  115.         B = self.H1
  116.         C = self.H2
  117.         D = self.H3
  118.         E = self.H4
  119.         for t in xrange(0, 80):
  120.             TEMP = _rotateLeft(A, 5) + f[t](B, C, D) + E + W[t] + K[t / 20]
  121.             E = D
  122.             D = C
  123.             C = _rotateLeft(B, 30) & 0xFFFFFFFFL
  124.             B = A
  125.             A = TEMP & 0xFFFFFFFFL
  126.         
  127.         self.H0 = self.H0 + A & 0xFFFFFFFFL
  128.         self.H1 = self.H1 + B & 0xFFFFFFFFL
  129.         self.H2 = self.H2 + C & 0xFFFFFFFFL
  130.         self.H3 = self.H3 + D & 0xFFFFFFFFL
  131.         self.H4 = self.H4 + E & 0xFFFFFFFFL
  132.  
  133.     
  134.     def update(self, inBuf):
  135.         leninBuf = long(len(inBuf))
  136.         index = self.count[1] >> 3 & 0x3FL
  137.         self.count[1] = self.count[1] + (leninBuf << 3)
  138.         if self.count[1] < leninBuf << 3:
  139.             self.count[0] = self.count[0] + 1
  140.         
  141.         self.count[0] = self.count[0] + (leninBuf >> 29)
  142.         partLen = 64 - index
  143.         if leninBuf >= partLen:
  144.             self.input[index:] = list(inBuf[:partLen])
  145.             self._transform(_bytelist2longBigEndian(self.input))
  146.             i = partLen
  147.             while i + 63 < leninBuf:
  148.                 self._transform(_bytelist2longBigEndian(list(inBuf[i:i + 64])))
  149.                 i = i + 64
  150.             self.input = list(inBuf[i:leninBuf])
  151.         else:
  152.             i = 0
  153.             self.input = self.input + list(inBuf)
  154.  
  155.     
  156.     def digest(self):
  157.         H0 = self.H0
  158.         H1 = self.H1
  159.         H2 = self.H2
  160.         H3 = self.H3
  161.         H4 = self.H4
  162.         input = [] + self.input
  163.         count = [] + self.count
  164.         index = self.count[1] >> 3 & 0x3FL
  165.         if index < 56:
  166.             padLen = 56 - index
  167.         else:
  168.             padLen = 120 - index
  169.         padding = [
  170.             '\x80'] + [
  171.             '\x00'] * 63
  172.         self.update(padding[:padLen])
  173.         bits = _bytelist2longBigEndian(self.input[:56]) + count
  174.         self._transform(bits)
  175.         digest = _long2bytesBigEndian(self.H0, 4) + _long2bytesBigEndian(self.H1, 4) + _long2bytesBigEndian(self.H2, 4) + _long2bytesBigEndian(self.H3, 4) + _long2bytesBigEndian(self.H4, 4)
  176.         self.H0 = H0
  177.         self.H1 = H1
  178.         self.H2 = H2
  179.         self.H3 = H3
  180.         self.H4 = H4
  181.         self.input = input
  182.         self.count = count
  183.         return digest
  184.  
  185.     
  186.     def hexdigest(self):
  187.         return []([ '%02x' % ord(c) for c in self.digest() ])
  188.  
  189.     
  190.     def copy(self):
  191.         return copy.deepcopy(self)
  192.  
  193.  
  194. digest_size = digestsize = 20
  195. blocksize = 1
  196.  
  197. def new(arg = None):
  198.     crypto = mssha1()
  199.     if arg:
  200.         crypto.update(arg)
  201.     
  202.     return crypto
  203.  
  204. if __name__ == '__main__':
  205.     
  206.     def main():
  207.         import sys
  208.         file = None
  209.         if len(sys.argv) > 2:
  210.             print 'usage: %s [FILE]' % sys.argv[0]
  211.             return None
  212.         if len(sys.argv) < 2:
  213.             file = sys.stdin
  214.         else:
  215.             file = open(sys.argv[1], 'rb')
  216.         context = new()
  217.         data = file.read(16384)
  218.         while data:
  219.             context.update(data)
  220.             data = file.read(16384)
  221.         file.close()
  222.         digest = context.hexdigest().upper()
  223.         for i in xrange(0, 40, 8):
  224.             print digest[i:i + 8],
  225.         
  226.         print 
  227.  
  228.     main()
  229.  
  230.