home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 February / maximum-cd-2011-02.iso / DiscContents / digsby_setup85.exe / lib / M2Crypto / PGP / packet.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-11-24  |  12.7 KB  |  403 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.6)
  3.  
  4. import struct
  5. import time
  6.  
  7. try:
  8.     from cStringIO import StringIO
  9. except ImportError:
  10.     from StringIO import StringIO
  11.  
  12. from M2Crypto import EVP, RSA
  13. from M2Crypto.util import octx_to_num
  14. from constants import *
  15. _OK_VERSION = ('\x02', '\x03')
  16. _OK_VALIDITY = ('\x00',)
  17. _OK_PKC = ('\x01',)
  18.  
  19. class packet:
  20.     
  21.     def __init__(self, ctb, body = None):
  22.         self.ctb = ctb
  23.         if body is not None:
  24.             self.body = StringIO(body)
  25.         else:
  26.             self.body = None
  27.  
  28.     
  29.     def validate(self):
  30.         return 1
  31.  
  32.     
  33.     def pack(self):
  34.         raise NotImplementedError, '%s.pack(): abstract method' % (self.__class__,)
  35.  
  36.     
  37.     def version(self):
  38.         if hasattr(self, '_version'):
  39.             return ord(self._version)
  40.         return None
  41.  
  42.     
  43.     def timestamp(self):
  44.         if hasattr(self, '_timestamp'):
  45.             return struct.unpack('>L', self._timestamp)[0]
  46.         return None
  47.  
  48.     
  49.     def validity(self):
  50.         if hasattr(self, '_validity'):
  51.             return struct.unpack('>H', self._validity)[0]
  52.         return None
  53.  
  54.     
  55.     def pkc(self):
  56.         if hasattr(self, '_pkc'):
  57.             return self._pkc
  58.         return None
  59.  
  60.     
  61.     def _llf(self, lenf):
  62.         if lenf < 256:
  63.             return (0, chr(lenf))
  64.         if lenf < 65536:
  65.             return (1, struct.pack('>H', lenf))
  66.         return (2, struct.pack('>L', lenf))
  67.  
  68.     
  69.     def _ctb(self, llf):
  70.         ctbv = _FACTORY[self.__class__]
  71.         return chr(128 | ctbv << 2 | llf)
  72.  
  73.  
  74.  
  75. class public_key_packet(packet):
  76.     
  77.     def __init__(self, ctb, body = None):
  78.         packet.__init__(self, ctb, body)
  79.         if self.body is not None:
  80.             self._version = self.body.read(1)
  81.             self._timestamp = self.body.read(4)
  82.             self._validity = self.body.read(2)
  83.             self._pkc = self.body.read(1)
  84.             self._nlen = self.body.read(2)
  85.             nlen = (struct.unpack('>H', self._nlen)[0] + 7) / 8
  86.             self._n = self.body.read(nlen)
  87.             self._elen = self.body.read(2)
  88.             elen = (struct.unpack('>H', self._elen)[0] + 7) / 8
  89.             self._e = self.body.read(elen)
  90.         
  91.  
  92.     
  93.     def pack(self):
  94.         if self.body is None:
  95.             self.body = StringIO()
  96.             self.body.write(self._version)
  97.             self.body.write(self._timestamp)
  98.             self.body.write(self._validity)
  99.             self.body.write(self._pkc)
  100.             self.body.write(self._nlen)
  101.             self.body.write(self._n)
  102.             self.body.write(self._elen)
  103.             self.body.write(self._e)
  104.         
  105.         self.body = self.body.getvalue()
  106.         (llf, lenf) = self._llf(len(self.body))
  107.         ctb = self._ctb(llf)
  108.         return '%s%s%s' % (ctb, lenf, self.body)
  109.  
  110.     
  111.     def pubkey(self):
  112.         return self._pubkey.pub()
  113.  
  114.  
  115.  
  116. class trust_packet(packet):
  117.     
  118.     def __init__(self, ctb, body = None):
  119.         packet.__init__(self, ctb, body)
  120.         if body is not None:
  121.             self.trust = self.body.read(1)
  122.         
  123.  
  124.  
  125.  
  126. class userid_packet(packet):
  127.     
  128.     def __init__(self, ctb, body = None):
  129.         packet.__init__(self, ctb, body)
  130.         if body is not None:
  131.             self._userid = body
  132.         
  133.  
  134.     
  135.     def pack(self):
  136.         if self.body is None:
  137.             self.body = StringIO()
  138.             self.body.write(chr(len(self._userid)))
  139.             self.body.write(self._userid)
  140.             self.body = self.body.getvalue()
  141.         
  142.         return self.ctb + self.body
  143.  
  144.     
  145.     def userid(self):
  146.         return self._userid
  147.  
  148.  
  149.  
  150. class comment_packet(packet):
  151.     
  152.     def __init__(self, ctb, body = None):
  153.         packet.__init__(self, ctb, body)
  154.         if body is not None:
  155.             self.comment = self.body.getvalue()
  156.         
  157.  
  158.     
  159.     def pack(self):
  160.         if self.body is None:
  161.             self.body = StringIO()
  162.             self.body.write(chr(len(self.comment)))
  163.             self.body.write(self.comment)
  164.             self.body = self.body.getvalue()
  165.         
  166.         return self.ctb + self.body
  167.  
  168.  
  169.  
  170. class signature_packet(packet):
  171.     
  172.     def __init__(self, ctb, body = None):
  173.         packet.__init__(self, ctb, body)
  174.         if body is not None:
  175.             self._version = self.body.read(1)
  176.             self._len_md_stuff = self.body.read(1)
  177.             self._classification = self.body.read(1)
  178.             self._timestamp = self.body.read(4)
  179.             self._keyid = self.body.read(8)
  180.             self._pkc = self.body.read(1)
  181.             self._md_algo = self.body.read(1)
  182.             self._md_chksum = self.body.read(2)
  183.             self._sig = self.body.read()
  184.         
  185.  
  186.     
  187.     def pack(self):
  188.         if self.body is None:
  189.             self.body = StringIO()
  190.             self.body.write(self._version)
  191.             self.body.write(self._len_md_stuff)
  192.             self.body.write(self._classification)
  193.             self.body.write(self._timestamp)
  194.             self.body.write(self._keyid)
  195.             self.body.write(self._pkc)
  196.             self.body.write(self._md_algo)
  197.             self.body.write(self._md_chksum)
  198.             self.body.write(self._sig)
  199.             self.body = self.body.getvalue()
  200.         
  201.         (llf, lenf) = self._llf(len(body))
  202.         self.ctb = self.ctb | llf
  203.         return '%s%s%s' % (self.ctb, lenf, self.body)
  204.  
  205.     
  206.     def validate(self):
  207.         if self._version not in _OK_VERSION:
  208.             return None
  209.         if self._len_md_stuff != '\x05':
  210.             return None
  211.  
  212.  
  213.  
  214. class private_key_packet(packet):
  215.     
  216.     def __init__(self, ctb, body = None):
  217.         packet.__init__(self, ctb, body)
  218.         if body is not None:
  219.             self._version = self.body.read(1)
  220.             self._timestamp = self.body.read(4)
  221.             self._validity = self.body.read(2)
  222.             self._pkc = self.body.read(1)
  223.             self._nlen = self.body.read(2)
  224.             nlen = (struct.unpack('>H', self._nlen)[0] + 7) / 8
  225.             self._n = self.body.read(nlen)
  226.             self._elen = self.body.read(2)
  227.             elen = (struct.unpack('>H', self._elen)[0] + 7) / 8
  228.             self._e = self.body.read(elen)
  229.             self._cipher = self.body.read(1)
  230.             if self._cipher == '\x01':
  231.                 self._iv = self.body.read(8)
  232.             else:
  233.                 self._iv = None
  234.             for param in [
  235.                 'd',
  236.                 'p',
  237.                 'q',
  238.                 'u']:
  239.                 _plen = self.body.read(2)
  240.                 setattr(self, '_' + param + 'len', _plen)
  241.                 plen = (struct.unpack('>H', _plen)[0] + 7) / 8
  242.                 setattr(self, '_' + param, self.body.read(plen))
  243.             
  244.             self._cksum = self.body.read(2)
  245.         
  246.  
  247.     
  248.     def is_encrypted(self):
  249.         return ord(self._cipher)
  250.  
  251.  
  252.  
  253. class cke_packet(packet):
  254.     
  255.     def __init__(self, ctb, body = None):
  256.         packet.__init__(self, ctb, body)
  257.         if body is not None:
  258.             self._iv = self.body.read(8)
  259.             self._cksum = self.body.read(2)
  260.             self._ctxt = self.body.read()
  261.         
  262.  
  263.  
  264.  
  265. class pke_packet(packet):
  266.     
  267.     def __init__(self, ctb, body = None):
  268.         packet.__init__(self, ctb, body)
  269.         if body is not None:
  270.             self._version = self.body.read(1)
  271.             self._keyid = self.body.read(8)
  272.             self._pkc = ord(self.body.read(1))
  273.             deklen = (struct.unpack('>H', self.body.read(2))[0] + 7) / 8
  274.             self._dek = octx_to_num(self.body.read(deklen))
  275.         
  276.  
  277.  
  278.  
  279. class literal_packet(packet):
  280.     
  281.     def __init__(self, ctb, body = None):
  282.         packet.__init__(self, ctb, body)
  283.         if body is not None:
  284.             self.fmode = self.body.read(1)
  285.             fnlen = self.body.read(1)
  286.             self.fname = self.body.read(fnlen)
  287.             self.ftime = self.body.read(4)
  288.         
  289.  
  290.  
  291.  
  292. class compressed_packet(packet):
  293.     
  294.     def __init__(self, ctb, stream):
  295.         packet.__init__(self, ctb, '')
  296.         if body is not None:
  297.             self.algo = stream.read(1)
  298.             self.data = stream.read()
  299.         
  300.  
  301.     
  302.     def validate(self):
  303.         return self.algo == '\x01'
  304.  
  305.     
  306.     def uncompress(self):
  307.         import zlib
  308.         decomp = zlib.decompressobj(-13)
  309.         stream = StringIO(decomp.decompress(self.data))
  310.         return stream
  311.  
  312.  
  313. _FACTORY = {
  314.     1: pke_packet,
  315.     2: signature_packet,
  316.     5: private_key_packet,
  317.     6: public_key_packet,
  318.     9: cke_packet,
  319.     11: literal_packet,
  320.     12: trust_packet,
  321.     13: userid_packet,
  322.     14: comment_packet,
  323.     pke_packet: 1,
  324.     signature_packet: 2,
  325.     private_key_packet: 5,
  326.     public_key_packet: 6,
  327.     cke_packet: 9,
  328.     literal_packet: 11,
  329.     trust_packet: 12,
  330.     userid_packet: 13,
  331.     comment_packet: 14 }
  332.  
  333. class packet_stream:
  334.     
  335.     def __init__(self, input):
  336.         self.stream = input
  337.         self.under_current = None
  338.         self._count = 0
  339.  
  340.     
  341.     def close(self):
  342.         self.stream.close()
  343.         if self.under_current is not None:
  344.             self.under_current.close()
  345.         
  346.  
  347.     
  348.     def read(self, keep_trying = 0):
  349.         while None:
  350.             ctb0 = self.stream.read(1)
  351.             if not ctb0:
  352.                 return None
  353.             ctb = ord(ctb0)
  354.             if is_ctb(ctb):
  355.                 break
  356.                 continue
  357.             if keep_trying:
  358.                 continue
  359.                 continue
  360.             raise XXXError
  361.             continue
  362.             ctbt = (ctb & 60) >> 2
  363.             if ctbt == CTB_COMPRESSED_DATA:
  364.                 self.under_current = self.stream
  365.                 cp = compressed_packet(ctb0, self.stream)
  366.                 self.stream = cp.uncompress()
  367.                 return self.read()
  368.             llf = ctb & 3
  369.             if llf == 0:
  370.                 lenf = ord(self.stream.read(1))
  371.             elif llf == 1:
  372.                 lenf = struct.unpack('>H', self.stream.read(2))[0]
  373.             elif llf == 2:
  374.                 lenf = struct.unpack('>L', self.stream.read(4))[0]
  375.             else:
  376.                 raise XXXError, 'impossible case'
  377.             body = (ctbt == CTB_COMPRESSED_DATA).stream.read(lenf)
  378.             if not body or len(body) != lenf:
  379.                 raise XXXError, 'corrupted packet'
  380.             len(body) != lenf
  381.             self._count = self.stream.tell()
  382.             
  383.             try:
  384.                 return _FACTORY[ctbt](ctb0, body)
  385.             except KeyError:
  386.                 return packet(ctb0, body)
  387.  
  388.             return None
  389.  
  390.     
  391.     def count(self):
  392.         return self._count
  393.  
  394.  
  395.  
  396. def is_ctb(ctb):
  397.     return ctb & 192
  398.  
  399.  
  400. def make_ctb(value, llf):
  401.     return chr(128 | value << 2 | llf)
  402.  
  403.