def decrypt(self, strData=None, hexData=None):
        """
		Decrypt the string data or hexa data string
		
		@param strData: data encrypted
		@type strData: string/none

		@param hexData: data in clear with hexa representation (example: bbaa01ffef)
		@type hexData: string/none

		@return: decrypted data
		@rtype: string
		"""
        if not len(self.key):
            raise Exception('No key defined')

        if strData is None and hexData is None:
            raise Exception('No data defined')

        if self.cipher is not None:
            raise Exception('Cipher not ready')

        # encrypt
        if strData is not None:
            cipher_ret = self.cipher.decrypt(strData)
        if hexData is not None:
            data_int = common.decodeHex(hexData, 2)
            data_str = []
            for d in data_int:
                data_str.append(chr(d))
            cipher_ret = self.cipher.decrypt("".join(data_str))

        return cipher_ret
    def encrypt(self, strData=None, hexData=None, hexdigit=False):
        """
		Encrypt the string data or hexa data string and return an encrypted string
		
		@param strData: data in clear
		@type strData: string/none

		@param hexData: data in clear with hexa representation (example: bbaa01ffef)
		@type hexData: string/none
		
		@param hexdigit: return hexadecimal representation (default=False) 
		@type hexdigit: boolean
		
		@return: encrypted data
		@rtype: string
		"""
        if not len(self.key):
            raise Exception('No key defined')

        if strData is None and hexData is None:
            raise Exception('No data defined')

        # encrypt str
        if strData is not None:
            raw = strData

        if hexData is not None:
            data_int = common.decodeHex(hexData, 2)
            data_str = []
            for d in data_int:
                data_str.append(chr(d))
            raw = ''.join(data_str)

        raw = self.pad(raw)
        iv = Random.new().read(AESCRYPTO.block_size)
        cipher = AESCRYPTO.new(self.getKey(strKey=True), AESCRYPTO.MODE_CBC,
                               iv)
        cipher_ret = base64.b64encode(iv + cipher.encrypt(raw))

        # convert to int
        ret_int = []
        for c in cipher_ret:
            ret_int.append(ord(c))

        # convert to hex or not ?
        ret = []
        if hexdigit:
            for d in ret_int:
                ret.append("%02x" % d)
        else:
            for d in ret_int:
                ret.append(chr(d))

        ret_str = ''.join(ret)
        return ret_str
    def encrypt(self, strData=None, hexData=None, hexdigit=False):
        """
		Encrypt the string data or hexa data string and return an encrypted string
		
		@param strData: data in clear
		@type strData: string/none

		@param hexData: data in clear with hexa representation (example: bbaa01ffef)
		@type hexData: string/none
		
		@param hexdigit: return hexadecimal representation (default=False) 
		@type hexdigit: boolean
		
		@return: encrypted data
		@rtype: string
		"""
        if not len(self.key):
            raise Exception('No key defined')

        if strData is None and hexData is None:
            raise Exception('No data defined')

        if self.cipher is not None:
            raise Exception('Cipher not ready')

        # encrypt
        if strData is not None:
            cipher_ret = self.cipher.encrypt(strData)
        if hexData is not None:
            data_int = common.decodeHex(hexData, 2)
            data_str = []
            for d in data_int:
                data_str.append(chr(d))
            cipher_ret = self.cipher.encrypt("".join(data_str))

        # convert to int
        ret_int = []
        for c in cipher_ret:
            ret_int.append(ord(c))

        # convert to hex or not ?
        ret = []
        if hexdigit:
            for d in ret_int:
                ret.append("%02x" % d)
        else:
            for d in ret_int:
                ret.append(chr(d))

        ret_str = ''.join(ret)
        return ret_str
    def __init__(self, hexKey=None, strKey=None):
        """
		Blowfish algorithm implementation
		"""
        self.p = None
        self.s0 = None
        self.s1 = None
        self.s2 = None
        self.s3 = None
        if hexKey is not None:
            self.setKey(common.decodeHex(hexKey, 2))
        if strKey is not None:
            key = []
            for c in strKey:
                key.append(ord(c))
            self.setKey(key)
	def encrypt (self, strData=None, hexData=None, hexdigit=False):
		"""
		Encrypt the string data or hexa data string and return an encrypted string
		
		@param strData: data in clear
		@type strData: string/none

		@param hexData: data in clear with hexa representation (example: bbaa01ffef)
		@type hexData: string/none
		
		@param hexdigit: return hexadecimal representation (default=False) 
		@type hexdigit: boolean
		
		@return: encrypted data
		@rtype: string
		"""
		if not len(self.key):
			raise Exception('No key defined')
		
		if strData is None and hexData is None:
			raise Exception('No data defined')
			
		# initialize
		self.ksa()
		self.pgra()

		# convert data to a list of int
		data_int =  []
		if strData is not None: 
			for c in strData: data_int.append( ord(c) )
		if hexData is not None:
			data_int = common.decodeHex(hexData, 2)
			
		# xor	
		ret_int = []
		for a in xrange(len(data_int)): 
			ret_int.append( data_int[a]^self.keyStream[a] )
		
		ret = []
		if hexdigit:
			for d in ret_int: ret.append( "%02x" % d )
		else:
			for d in ret_int: ret.append( chr(d) )
		
		ret_str = ''.join(ret)	
		return ret_str
	def setKey(self, hexKey=None, strKey=None):
		"""
		Set the key string or hexadecimal representation passed in argument
		
		@param strKey: string key
		@type strKey: string/none
		
		@param hexKey: hexadecimal key
		@type hexKey: string/none
		"""
		if strKey is not None:
			for c in strKey:
				self.key.append( ord(c) )
		elif hexKey is not None:
			self.key = common.decodeHex(hexKey, 2)
		else:
			raise Exception('No key defined')
    def encrypt(self, strData=None, hexData=None, hexdigit=False):
        """
		Encrypts a given string using the preprocessed key.

		@param strData: data string to decrypt
		@type strData: string/none
		
		@param hexData: a hexadecimal string (ex: AADEFFBB01)
		@type hexData: string/none

		@return: data encrypted
		@rtype: string
		"""
        if strData is None and hexData is None:
            raise Exception('No data defined')

        nBytes = self.encryptor.blockSize << 2

        # perform ECB encryption
        if self.mode == MODE_ECB:
            # normalize data to a list of 32bits number
            if strData is not None:
                aWords = common.decodeBytes(strData, 4)
            if hexData is not None:
                aWords = common.decodeHex(hexData, 8)

            if (len(aWords) % self.encryptor.blockSize):
                raise Exception(
                    "length of byte string must be a multiple of %s to encrypt."
                    % nBytes)

            e = self.encryptor.encrypt(aWords)  # e is a list of 32bits numbers
            r = common.encodeBytes(e)  # convert to a list of string

        # perform CBC encryption
        if self.mode == MODE_CBC:
            r = self.encryptor.encrypt(strData)  # return list of string

        str_encrypted = "".join(r)
        if hexdigit:
            return binascii.hexlify(str_encrypted)
        else:
            return str_encrypted
    def setKey(self, hexKey=None, strKey=None):
        """
		Set the key to intialize the encryption/decryption.

		@param hexKey: a hexadecimal string representing 32 to 448 bits (8 to 56 bytes)
		@type hexKey: string/none
	
		@param strKey: a key string representing 32 to 448 bits (8 to 56 bytes)
		@type strKey: string/none
		"""
        if strKey is not None:
            for c in strKey:
                self.key.append(ord(c))
            self.blowfish.setKey(self.key)
        elif hexKey is not None:
            key = common.decodeHex(hexKey, 2)
            self.blowfish.setKey(key)
            self.key = key
        else:
            raise Exception('No key defined')
    def decrypt(self, strData=None, hexData=None, hexdigit=False):
        """
		Decrypts a given hexadecimal string using the preprocessed key.

		@param strData: data string to decrypt
		@type strData: string/none
		
		@param hexData: a hexadecimal string
		@type hexData: string/none

		@return: data decrypted
		@rtype: string
		"""
        if strData is None and hexData is None:
            raise Exception('No data defined')

        # perform ECB decryption
        if self.mode == MODE_ECB:
            nHexes = self.encryptor.blockSize << 3

            if strData is not None:
                aWords = common.decodeBytes(strData, 4)

            if hexData is not None:
                aWords = common.decodeHex(hexData, 8)

            if (len(aWords) % self.encryptor.blockSize):
                raise Exception(
                    "length of hexadecimal string must be a multiple of %s to decrypt."
                    % nHexes)

            # perform decryption
            d = self.encryptor.decrypt(aWords)
            rBytes = common.encodeBytes(d)

            return "".join(rBytes)

        # perform CBC decryption
        if self.mode == MODE_CBC:
            r = self.encryptor.decrypt(strData)
            return "".join(r)
    def decrypt(self, strData=None, hexData=None):
        """
		Decrypt the string data or hexa data string
		
		@param strData: data encrypted
		@type strData: string/none

		@param hexData: data in clear with hexa representation (example: bbaa01ffef)
		@type hexData: string/none

		@return: decrypted data
		@rtype: string
		"""
        if not len(self.key):
            raise Exception('No key defined')

        if strData is None and hexData is None:
            raise Exception('No data defined')

        # encrypt
        if strData is not None:
            enc = data_str

        if hexData is not None:
            data_int = common.decodeHex(hexData, 2)
            data_str = []
            for d in data_int:
                data_str.append(chr(d))
            enc = ''.join(data_str)

        enc = base64.b64decode(enc)
        iv = enc[:AESCRYPTO.block_size]
        cipher = AESCRYPTO.new(self.getKey(strKey=True), AESCRYPTO.MODE_CBC,
                               iv)
        cipher_ret = self.unpad(cipher.decrypt(enc[AESCRYPTO.block_size:]))

        return cipher_ret