API tools faq
paste
Advertisement
P3NG3R

[METIN2] pyDes Tool

P3NG3R
Sep 25th, 2013
405
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Python 15.67 KB | None | 0 0
raw download clone embed print report
  1. import sys
  2. import cStringIO
  3. import cPickle
  4.  
  5. Password = "testpassword___________."
  6. _pythonMajorVersion = sys.version_info[0]
  7. ECB = 0
  8. CBC = 1
  9. PAD_NORMAL = 1
  10. PAD_PKCS5 = 2
  11.  
  12. class _baseDes(object):
  13.     def __init__(self, mode=ECB, IV=None, pad=None, padmode=PAD_NORMAL):
  14.         if IV:
  15.             IV = self._guardAgainstUnicode(IV)
  16.  
  17.         if pad:
  18.             pad = self._guardAgainstUnicode(pad)
  19.  
  20.         self.block_size = 8
  21.         if pad and padmode == PAD_PKCS5:
  22.             raise ValueError("Cannot use a pad character with PAD_PKCS5")
  23.  
  24.         if IV and len(IV) != self.block_size:
  25.             raise ValueError("Invalid Initial Value (IV), must be a multiple of " + str(self.block_size) + " bytes")
  26.  
  27.         self._mode = mode
  28.         self._iv = IV
  29.         self._padding = pad
  30.         self._padmode = padmode
  31.  
  32.     def getKey(self):
  33.         return self.__key
  34.  
  35.     def setKey(self, key):
  36.         key = self._guardAgainstUnicode(key)
  37.         self.__key = key
  38.  
  39.     def getMode(self):
  40.         return self._mode
  41.  
  42.     def setMode(self, mode):
  43.         self._mode = mode
  44.  
  45.     def getPadding(self):
  46.         return self._padding
  47.  
  48.     def setPadding(self, pad):
  49.         if pad is not None:
  50.             pad = self._guardAgainstUnicode(pad)
  51.  
  52.         self._padding = pad
  53.  
  54.     def getPadMode(self):
  55.         return self._padmode
  56.  
  57.     def setPadMode(self, mode):
  58.         self._padmode = mode
  59.  
  60.     def getIV(self):
  61.         return self._iv
  62.  
  63.     def setIV(self, IV):
  64.         if not IV or len(IV) != self.block_size:
  65.             raise ValueError("Invalid Initial Value (IV), must be a multiple of " + str(self.block_size) + " bytes")
  66.  
  67.         IV = self._guardAgainstUnicode(IV)
  68.         self._iv = IV
  69.  
  70.     def _padData(self, data, pad, padmode):
  71.         if padmode is None:
  72.             padmode = self.getPadMode()
  73.  
  74.         if pad and padmode == PAD_PKCS5:
  75.             raise ValueError("Cannot use a pad character with PAD_PKCS5")
  76.  
  77.         if padmode == PAD_NORMAL:
  78.             if len(data) % self.block_size == 0:
  79.                 return data
  80.  
  81.             if not pad:
  82.                 pad = self.getPadding()
  83.  
  84.             if not pad:
  85.                 raise ValueError("Data must be a multiple of " + str(self.block_size) + " bytes in length. Use padmode=PAD_PKCS5 or set the pad character.")
  86.  
  87.             data += (self.block_size - (len(data) % self.block_size)) * pad
  88.  
  89.         elif padmode == PAD_PKCS5:
  90.             pad_len = 8 - (len(data) % self.block_size)
  91.             if _pythonMajorVersion < 3:
  92.                 data += pad_len * chr(pad_len)
  93.             else:
  94.                 data += bytes([pad_len] * pad_len)
  95.  
  96.         return data
  97.  
  98.     def _unpadData(self, data, pad, padmode):
  99.         if not data:
  100.             return data
  101.  
  102.         if pad and padmode == PAD_PKCS5:
  103.             raise ValueError("Cannot use a pad character with PAD_PKCS5")
  104.  
  105.         if padmode is None:
  106.             padmode = self.getPadMode()
  107.  
  108.         if padmode == PAD_NORMAL:
  109.             if not pad:
  110.                 pad = self.getPadding()
  111.  
  112.             if pad:
  113.                 data = data[:-self.block_size] + data[-self.block_size:].rstrip(pad)
  114.  
  115.         elif padmode == PAD_PKCS5:
  116.             if _pythonMajorVersion < 3:
  117.                 pad_len = ord(data[-1])
  118.             else:
  119.                 pad_len = data[-1]
  120.  
  121.             data = data[:-pad_len]
  122.  
  123.         return data
  124.  
  125.     def _guardAgainstUnicode(self, data):
  126.         if _pythonMajorVersion < 3:
  127.             if isinstance(data, unicode):
  128.                 raise ValueError("pyDes can only work with bytes, not Unicode strings.")
  129.         else:
  130.             if isinstance(data, str):
  131.                 try:
  132.                     return data.encode('ascii')
  133.                 except UnicodeEncodeError:
  134.                     pass
  135.  
  136.                 raise ValueError("pyDes can only work with encoded strings, not Unicode.")
  137.  
  138.         return data
  139.  
  140. class des(_baseDes):
  141.     __pc1 = [
  142.         56, 48, 40, 32, 24, 16,  8,
  143.          0, 57, 49, 41, 33, 25, 17,
  144.          9,  1, 58, 50, 42, 34, 26,
  145.         18, 10,  2, 59, 51, 43, 35,
  146.         62, 54, 46, 38, 30, 22, 14,
  147.          6, 61, 53, 45, 37, 29, 21,
  148.         13,  5, 60, 52, 44, 36, 28,
  149.         20, 12,  4, 27, 19, 11,  3
  150.     ]
  151.     __left_rotations = [
  152.         1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1
  153.     ]
  154.     __pc2 = [
  155.         13, 16, 10, 23,  0,  4,
  156.          2, 27, 14,  5, 20,  9,
  157.         22, 18, 11,  3, 25,  7,
  158.         15,  6, 26, 19, 12,  1,
  159.         40, 51, 30, 36, 46, 54,
  160.         29, 39, 50, 44, 32, 47,
  161.         43, 48, 38, 55, 33, 52,
  162.         45, 41, 49, 35, 28, 31
  163.     ]
  164.     __ip = [
  165.         57, 49, 41, 33, 25, 17, 9,  1,
  166.         59, 51, 43, 35, 27, 19, 11, 3,
  167.         61, 53, 45, 37, 29, 21, 13, 5,
  168.         63, 55, 47, 39, 31, 23, 15, 7,
  169.         56, 48, 40, 32, 24, 16, 8,  0,
  170.         58, 50, 42, 34, 26, 18, 10, 2,
  171.         60, 52, 44, 36, 28, 20, 12, 4,
  172.         62, 54, 46, 38, 30, 22, 14, 6
  173.     ]
  174.     __expansion_table = [
  175.         31,  0,  1,  2,  3,  4,
  176.          3,  4,  5,  6,  7,  8,
  177.          7,  8,  9, 10, 11, 12,
  178.         11, 12, 13, 14, 15, 16,
  179.         15, 16, 17, 18, 19, 20,
  180.         19, 20, 21, 22, 23, 24,
  181.         23, 24, 25, 26, 27, 28,
  182.         27, 28, 29, 30, 31,  0
  183.     ]
  184.     __sbox = [
  185.         [14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7,
  186.          0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8,
  187.          4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0,
  188.          15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13],
  189.         [15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10,
  190.          3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5,
  191.          0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15,
  192.          13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9],
  193.         [10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8,
  194.          13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1,
  195.          13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7,
  196.          1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12],
  197.         [7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15,
  198.          13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9,
  199.          10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4,
  200.          3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14],
  201.         [2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9,
  202.          14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6,
  203.          4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14,
  204.          11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3],
  205.         [12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11,
  206.          10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8,
  207.          9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6,
  208.          4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13],
  209.         [4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1,
  210.          13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6,
  211.          1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2,
  212.          6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12],
  213.         [13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7,
  214.          1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2,
  215.          7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8,
  216.          2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11],
  217.     ]
  218.     __p = [
  219.         15, 6, 19, 20, 28, 11,
  220.         27, 16, 0, 14, 22, 25,
  221.         4, 17, 30, 9, 1, 7,
  222.         23,13, 31, 26, 2, 8,
  223.         18, 12, 29, 5, 21, 10,
  224.         3, 24
  225.     ]
  226.     __fp = [
  227.         39,  7, 47, 15, 55, 23, 63, 31,
  228.         38,  6, 46, 14, 54, 22, 62, 30,
  229.         37,  5, 45, 13, 53, 21, 61, 29,
  230.         36,  4, 44, 12, 52, 20, 60, 28,
  231.         35,  3, 43, 11, 51, 19, 59, 27,
  232.         34,  2, 42, 10, 50, 18, 58, 26,
  233.         33,  1, 41,  9, 49, 17, 57, 25,
  234.         32,  0, 40,  8, 48, 16, 56, 24
  235.     ]
  236.  
  237.     ENCRYPT =   0x00
  238.     DECRYPT =   0x01
  239.  
  240.     def __init__(self, key, mode=ECB, IV=None, pad=None, padmode=PAD_NORMAL):
  241.         if len(key) != 8:
  242.             raise ValueError("Invalid DES key size. Key must be exactly 8 bytes long.")
  243.  
  244.         _baseDes.__init__(self, mode, IV, pad, padmode)
  245.         self.key_size = 8
  246.         self.L = []
  247.         self.R = []
  248.         self.Kn = [ [0] * 48 ] * 16 # 16 48-bit keys (K1 - K16)
  249.         self.final = []
  250.         self.setKey(key)
  251.  
  252.     def setKey(self, key):
  253.         _baseDes.setKey(self, key)
  254.         self.__create_sub_keys()
  255.  
  256.     def __String_to_BitList(self, data):
  257.         if _pythonMajorVersion < 3:
  258.             data = [ord(c) for c in data]
  259.  
  260.         l = len(data) * 8
  261.         result = [0] * l
  262.         pos = 0
  263.         for ch in data:
  264.             i = 7
  265.             while i >= 0:
  266.                 if ch & (1 << i) != 0:
  267.                     result[pos] = 1
  268.                 else:
  269.                     result[pos] = 0
  270.  
  271.                 pos += 1
  272.                 i -= 1
  273.  
  274.         return result
  275.  
  276.     def __BitList_to_String(self, data):
  277.         result = []
  278.         pos = 0
  279.         c = 0
  280.         while pos < len(data):
  281.             c += data[pos] << (7 - (pos % 8))
  282.             if (pos % 8) == 7:
  283.                 result.append(c)
  284.                 c = 0
  285.  
  286.             pos += 1
  287.  
  288.         if _pythonMajorVersion < 3:
  289.             return ''.join([ chr(c) for c in result ])
  290.         else:
  291.             return bytes(result)
  292.  
  293.     def __permutate(self, table, block):
  294.         return list(map(lambda x: block[x], table))
  295.  
  296.     def __create_sub_keys(self):
  297.         key = self.__permutate(des.__pc1, self.__String_to_BitList(self.getKey()))
  298.         i = 0
  299.         self.L = key[:28]
  300.         self.R = key[28:]
  301.         while i < 16:
  302.             j = 0
  303.             while j < des.__left_rotations[i]:
  304.                 self.L.append(self.L[0])
  305.                 del self.L[0]
  306.                 self.R.append(self.R[0])
  307.                 del self.R[0]
  308.                 j += 1
  309.  
  310.             self.Kn[i] = self.__permutate(des.__pc2, self.L + self.R)
  311.             i += 1
  312.  
  313.     def __des_crypt(self, block, crypt_type):
  314.         block = self.__permutate(des.__ip, block)
  315.         self.L = block[:32]
  316.         self.R = block[32:]
  317.         if crypt_type == des.ENCRYPT:
  318.             iteration = 0
  319.             iteration_adjustment = 1
  320.         else:
  321.             iteration = 15
  322.             iteration_adjustment = -1
  323.  
  324.         i = 0
  325.         while i < 16:
  326.             tempR = self.R[:]
  327.             self.R = self.__permutate(des.__expansion_table, self.R)
  328.             self.R = list(map(lambda x, y: x ^ y, self.R, self.Kn[iteration]))
  329.             B = [self.R[:6], self.R[6:12], self.R[12:18], self.R[18:24], self.R[24:30], self.R[30:36], self.R[36:42], self.R[42:]]
  330.             j = 0
  331.             Bn = [0] * 32
  332.             pos = 0
  333.             while j < 8:
  334.                 m = (B[j][0] << 1) + B[j][5]
  335.                 n = (B[j][1] << 3) + (B[j][2] << 2) + (B[j][3] << 1) + B[j][4]
  336.                 v = des.__sbox[j][(m << 4) + n]
  337.                 Bn[pos] = (v & 8) >> 3
  338.                 Bn[pos + 1] = (v & 4) >> 2
  339.                 Bn[pos + 2] = (v & 2) >> 1
  340.                 Bn[pos + 3] = v & 1
  341.                 pos += 4
  342.                 j += 1
  343.  
  344.             self.R = self.__permutate(des.__p, Bn)
  345.             self.R = list(map(lambda x, y: x ^ y, self.R, self.L))
  346.             self.L = tempR
  347.             i += 1
  348.             iteration += iteration_adjustment
  349.  
  350.         self.final = self.__permutate(des.__fp, self.R + self.L)
  351.         return self.final
  352.  
  353.     def crypt(self, data, crypt_type):
  354.         if not data:
  355.             return ''
  356.  
  357.         if len(data) % self.block_size != 0:
  358.             if crypt_type == des.DECRYPT:
  359.                 raise ValueError("Invalid data length, data must be a multiple of " + str(self.block_size) + " bytes\n.")
  360.  
  361.             if not self.getPadding():
  362.                 raise ValueError("Invalid data length, data must be a multiple of " + str(self.block_size) + " bytes\n. Try setting the optional padding character")
  363.             else:
  364.                 data += (self.block_size - (len(data) % self.block_size)) * self.getPadding()
  365.  
  366.         if self.getMode() == CBC:
  367.             if self.getIV():
  368.                 iv = self.__String_to_BitList(self.getIV())
  369.             else:
  370.                 raise ValueError("For CBC mode, you must supply the Initial Value (IV) for ciphering")
  371.  
  372.         i = 0
  373.         dict = {}
  374.         result = []
  375.         while i < len(data):
  376.             block = self.__String_to_BitList(data[i:i+8])
  377.             if self.getMode() == CBC:
  378.                 if crypt_type == des.ENCRYPT:
  379.                     block = list(map(lambda x, y: x ^ y, block, iv))
  380.  
  381.                 processed_block = self.__des_crypt(block, crypt_type)
  382.                 if crypt_type == des.DECRYPT:
  383.                     processed_block = list(map(lambda x, y: x ^ y, processed_block, iv))
  384.                     iv = block
  385.                 else:
  386.                     iv = processed_block
  387.             else:
  388.                 processed_block = self.__des_crypt(block, crypt_type)
  389.  
  390.             result.append(self.__BitList_to_String(processed_block))
  391.             i += 8
  392.  
  393.         if _pythonMajorVersion < 3:
  394.             return ''.join(result)
  395.         else:
  396.             return bytes.fromhex('').join(result)
  397.  
  398.     def encrypt(self, data, pad=None, padmode=None):
  399.         data = self._guardAgainstUnicode(data)
  400.         if pad is not None:
  401.             pad = self._guardAgainstUnicode(pad)
  402.  
  403.         data = self._padData(data, pad, padmode)
  404.         return self.crypt(data, des.ENCRYPT)
  405.  
  406.     def decrypt(self, data, pad=None, padmode=None):
  407.         data = self._guardAgainstUnicode(data)
  408.         if pad is not None:
  409.             pad = self._guardAgainstUnicode(pad)
  410.  
  411.         data = self.crypt(data, des.DECRYPT)
  412.         return self._unpadData(data, pad, padmode)
  413.  
  414. class triple_des(_baseDes):
  415.     def __init__(self, key, mode=ECB, IV=None, pad=None, padmode=PAD_NORMAL):
  416.         _baseDes.__init__(self, mode, IV, pad, padmode)
  417.         self.setKey(key)
  418.  
  419.     def setKey(self, key):
  420.         self.key_size = 24
  421.         if len(key) != self.key_size:
  422.             if len(key) == 16:
  423.                 self.key_size = 16
  424.             else:
  425.                 raise ValueError("Invalid triple DES key size. Key must be either 16 or 24 bytes long")
  426.  
  427.         if self.getMode() == CBC:
  428.             if not self.getIV():
  429.                 self.setIV(key[:self.block_size])
  430.  
  431.             if len(self.getIV()) != self.block_size:
  432.                 raise ValueError("Invalid IV, must be 8 bytes in length")
  433.  
  434.         self.__key1 = des(key[:8], self._mode, self._iv, self._padding, self._padmode)
  435.         self.__key2 = des(key[8:16], self._mode, self._iv, self._padding, self._padmode)
  436.         if self.key_size == 16:
  437.             self.__key3 = self.__key1
  438.         else:
  439.             self.__key3 = des(key[16:], self._mode, self._iv, self._padding, self._padmode)
  440.  
  441.         _baseDes.setKey(self, key)
  442.  
  443.     def setMode(self, mode):
  444.         _baseDes.setMode(self, mode)
  445.         for key in (self.__key1, self.__key2, self.__key3):
  446.             key.setMode(mode)
  447.  
  448.     def setPadding(self, pad):
  449.         _baseDes.setPadding(self, pad)
  450.         for key in (self.__key1, self.__key2, self.__key3):
  451.             key.setPadding(pad)
  452.  
  453.     def setPadMode(self, mode):
  454.         _baseDes.setPadMode(self, mode)
  455.         for key in (self.__key1, self.__key2, self.__key3):
  456.             key.setPadMode(mode)
  457.  
  458.     def setIV(self, IV):
  459.         _baseDes.setIV(self, IV)
  460.         for key in (self.__key1, self.__key2, self.__key3):
  461.             key.setIV(IV)
  462.  
  463.     def encrypt(self, data, pad=None, padmode=None):
  464.         ENCRYPT = des.ENCRYPT
  465.         DECRYPT = des.DECRYPT
  466.         data = self._guardAgainstUnicode(data)
  467.         if pad is not None:
  468.             pad = self._guardAgainstUnicode(pad)
  469.  
  470.         data = self._padData(data, pad, padmode)
  471.         if self.getMode() == CBC:
  472.             self.__key1.setIV(self.getIV())
  473.             self.__key2.setIV(self.getIV())
  474.             self.__key3.setIV(self.getIV())
  475.             i = 0
  476.             result = []
  477.             while i < len(data):
  478.                 block = self.__key1.crypt(data[i:i+8], ENCRYPT)
  479.                 block = self.__key2.crypt(block, DECRYPT)
  480.                 block = self.__key3.crypt(block, ENCRYPT)
  481.                 self.__key1.setIV(block)
  482.                 self.__key2.setIV(block)
  483.                 self.__key3.setIV(block)
  484.                 result.append(block)
  485.                 i += 8
  486.  
  487.             if _pythonMajorVersion < 3:
  488.                 return ''.join(result)
  489.             else:
  490.                 return bytes.fromhex('').join(result)
  491.  
  492.         else:
  493.             data = self.__key1.crypt(data, ENCRYPT)
  494.             data = self.__key2.crypt(data, DECRYPT)
  495.             return self.__key3.crypt(data, ENCRYPT)
  496.  
  497.     def decrypt(self, data, pad=None, padmode=None):
  498.         ENCRYPT = des.ENCRYPT
  499.         DECRYPT = des.DECRYPT
  500.         data = self._guardAgainstUnicode(data)
  501.         if pad is not None:
  502.             pad = self._guardAgainstUnicode(pad)
  503.  
  504.         if self.getMode() == CBC:
  505.             self.__key1.setIV(self.getIV())
  506.             self.__key2.setIV(self.getIV())
  507.             self.__key3.setIV(self.getIV())
  508.             i = 0
  509.             result = []
  510.             while i < len(data):
  511.                 iv = data[i:i+8]
  512.                 block = self.__key3.crypt(iv,    DECRYPT)
  513.                 block = self.__key2.crypt(block, ENCRYPT)
  514.                 block = self.__key1.crypt(block, DECRYPT)
  515.                 self.__key1.setIV(iv)
  516.                 self.__key2.setIV(iv)
  517.                 self.__key3.setIV(iv)
  518.                 result.append(block)
  519.                 i += 8
  520.  
  521.             if _pythonMajorVersion < 3:
  522.                 data = ''.join(result)
  523.             else:
  524.                 data = bytes.fromhex('').join(result)
  525.  
  526.         else:
  527.             data = self.__key3.crypt(data, DECRYPT)
  528.             data = self.__key2.crypt(data, ENCRYPT)
  529.             data = self.__key1.crypt(data, DECRYPT)
  530.  
  531.         return self._unpadData(data, pad, padmode)
  532.  
  533. def EncodeString(data, key=None):
  534.     if key == None:
  535.         key = Password
  536.  
  537.     start = 0
  538.     encoded_string = ""
  539.     while 1:
  540.         chunk = cPickle.dumps(data)[start:start+16]
  541.         start += 16
  542.  
  543.         if len(chunk) == 0:
  544.             break
  545.  
  546.         if len(chunk) % 16 != 0:
  547.             chunk += ' ' * (16 - len(chunk) % 16)
  548.  
  549.         encoded_string += triple_des(key).encrypt(chunk)
  550.  
  551.     return encoded_string
  552.  
  553. def DecodeString(data, key=None):
  554.     if key == None:
  555.         key = Password
  556.  
  557.     return cPickle.loads(triple_des(key).decrypt(data))
  558.  
  559. def EncodeFile(filename, data, key=None):
  560.     if key == None:
  561.         key = Password
  562.  
  563.     outfile = open(filename, 'wb')
  564.     start = 0
  565.     while 1:
  566.         chunk = cPickle.dumps(data)[start:start+16]
  567.         start += 16
  568.  
  569.         if len(chunk) == 0:
  570.             break
  571.  
  572.         if len(chunk) % 16 != 0:
  573.             chunk += ' ' * (16 - len(chunk) % 16)
  574.  
  575.         outfile.write(triple_des(key).encrypt(chunk))
  576.  
  577.     outfile.close()
  578.  
  579. def DecodeFile(filename, key=None):
  580.     if key == None:
  581.         key = Password
  582.  
  583.     return cPickle.loads(triple_des(key).decrypt(open(filename, 'rb').read()))
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!