Python源码示例：Crypto.Cipher.AES.MODE_OFB
示例1
def encrypt( raw, key, iv ):
"""
Encrypt the raw data using the provided key and initial IV. Data will be
encrypted using AES OFB mode.
Args:
raw: plaintext data to be encrypted
key: AES key used for encryption
iv: Initial IV used for encryption
"""
result = ''
tmp_iv = iv
text = pad(raw)
for i in xrange(0, len(text) / BS):
lower_bound = i * 16
upper_bound = (i+1) * 16
tmp = AES.new(key, AES.MODE_OFB, tmp_iv).decrypt( text[lower_bound:upper_bound] )
tmp_iv = tmp
result += tmp
return result
示例2
def decrypt( raw, key, iv ):
"""
Decrypt the raw data using the provided key and iv.
Netwire encrypts data using AES OFB mode. Initial IV is sent in the key exchange
packet. This iv will decrypt the initial block of 16 bytes of data, each
subsequent block will use the previous block as an IV.
Args:
raw: raw data to be decrypted
key: AES key used to decrypt the data
iv: initial IV used for decryption
"""
result = ''
tmp_iv = iv
ciphertext = pad(raw)
for i in xrange(0, len(ciphertext) / BS):
lower_bound = i * 16
upper_bound = (i+1) * 16
tmp = AES.new(key, AES.MODE_OFB, tmp_iv).decrypt( ciphertext[lower_bound:upper_bound] )
tmp_iv = ciphertext[lower_bound:upper_bound]
result += tmp
return result
示例3
def encrypt( raw, key, iv ):
"""
Encrypt the raw data using the provided key and initial IV. Data will be
encrypted using AES OFB mode.
Args:
raw: plaintext data to be encrypted
key: AES key used for encryption
iv: Initial IV used for encryption
"""
result = ''
tmp_iv = iv
text = pad(raw)
for i in xrange(0, len(text) / BS):
lower_bound = i * 16
upper_bound = (i+1) * 16
tmp = AES.new(key, AES.MODE_OFB, tmp_iv).decrypt( text[lower_bound:upper_bound] )
tmp_iv = tmp
result += tmp
return result
示例4
def decrypt( raw, key, iv ):
"""
Decrypt the raw data using the provided key and iv.
Netwire encrypts data using AES OFB mode. Initial IV is sent in the key exchange
packet. This iv will decrypt the initial block of 16 bytes of data, each
subsequent block will use the previous block as an IV.
Args:
raw: raw data to be decrypted
key: AES key used to decrypt the data
iv: initial IV used for decryption
"""
result = ''
tmp_iv = iv
ciphertext = pad(raw)
for i in xrange(0, len(ciphertext) / BS):
lower_bound = i * 16
upper_bound = (i+1) * 16
tmp = AES.new(key, AES.MODE_OFB, tmp_iv).decrypt( ciphertext[lower_bound:upper_bound] )
tmp_iv = ciphertext[lower_bound:upper_bound]
result += tmp
return result
示例5
def prompt_encrypt(self):
"""ask for key, secret and password on the command line,
then encrypt the secret and store it in the ini file."""
print("Please copy/paste key and secret from exchange and")
print("then provide a password to encrypt them.")
print("")
key = input(" key: ").strip()
secret = input(" secret: ").strip()
while True:
password1 = getpass.getpass(" password: ").strip()
if password1 == "":
print("aborting")
return
password2 = getpass.getpass("password (again): ").strip()
if password1 != password2:
print("you had a typo in the password. try again...")
else:
break
hashed_pass = hashlib.sha512(password1.encode("utf-8")).digest()
crypt_key = hashed_pass[:32]
crypt_ini = hashed_pass[-16:]
aes = AES.new(crypt_key, AES.MODE_OFB, crypt_ini)
# since the secret is a base64 string we can just just pad it with
# spaces which can easily be stripped again after decryping
print(len(secret))
secret += " " * (16 - len(secret) % 16)
print(len(secret))
secret = base64.b64encode(aes.encrypt(secret)).decode("ascii")
self.config.set("api", "secret_key", key)
self.config.set("api", "secret_secret", secret)
self.config.save()
print("encrypted secret has been saved in %s" % self.config.filename)
示例6
def setup(self):
from Crypto.Cipher import AES
self.cipher = AES.new(self.key, AES.MODE_OFB, iv=self.iv)
示例7
def test_aes_128(self):
plaintext = '6bc1bee22e409f96e93d7e117393172a' +\
'ae2d8a571e03ac9c9eb76fac45af8e51' +\
'30c81c46a35ce411e5fbc1191a0a52ef' +\
'f69f2445df4f9b17ad2b417be66c3710'
ciphertext = '3b3fd92eb72dad20333449f8e83cfb4a' +\
'7789508d16918f03f53c52dac54ed825' +\
'9740051e9c5fecf64344f7a82260edcc' +\
'304c6528f659c77866a510d9c1d6ae5e'
key = '2b7e151628aed2a6abf7158809cf4f3c'
iv = '000102030405060708090a0b0c0d0e0f'
key = unhexlify(key)
iv = unhexlify(iv)
plaintext = unhexlify(plaintext)
ciphertext = unhexlify(ciphertext)
cipher = AES.new(key, AES.MODE_OFB, iv)
self.assertEqual(cipher.encrypt(plaintext), ciphertext)
cipher = AES.new(key, AES.MODE_OFB, iv)
self.assertEqual(cipher.decrypt(ciphertext), plaintext)
cipher = AES.new(key, AES.MODE_OFB, iv)
self.assertEqual(cipher.encrypt(plaintext[:-8]), ciphertext[:-8])
cipher = AES.new(key, AES.MODE_OFB, iv)
self.assertEqual(cipher.decrypt(ciphertext[:-8]), plaintext[:-8])
示例8
def test_aes_192(self):
plaintext = '6bc1bee22e409f96e93d7e117393172a' +\
'ae2d8a571e03ac9c9eb76fac45af8e51' +\
'30c81c46a35ce411e5fbc1191a0a52ef' +\
'f69f2445df4f9b17ad2b417be66c3710'
ciphertext = 'cdc80d6fddf18cab34c25909c99a4174' +\
'fcc28b8d4c63837c09e81700c1100401' +\
'8d9a9aeac0f6596f559c6d4daf59a5f2' +\
'6d9f200857ca6c3e9cac524bd9acc92a'
key = '8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b'
iv = '000102030405060708090a0b0c0d0e0f'
key = unhexlify(key)
iv = unhexlify(iv)
plaintext = unhexlify(plaintext)
ciphertext = unhexlify(ciphertext)
cipher = AES.new(key, AES.MODE_OFB, iv)
self.assertEqual(cipher.encrypt(plaintext), ciphertext)
cipher = AES.new(key, AES.MODE_OFB, iv)
self.assertEqual(cipher.decrypt(ciphertext), plaintext)
cipher = AES.new(key, AES.MODE_OFB, iv)
self.assertEqual(cipher.encrypt(plaintext[:-8]), ciphertext[:-8])
cipher = AES.new(key, AES.MODE_OFB, iv)
self.assertEqual(cipher.decrypt(ciphertext[:-8]), plaintext[:-8])
示例9
def test_aes_256(self):
plaintext = '6bc1bee22e409f96e93d7e117393172a' +\
'ae2d8a571e03ac9c9eb76fac45af8e51' +\
'30c81c46a35ce411e5fbc1191a0a52ef' +\
'f69f2445df4f9b17ad2b417be66c3710'
ciphertext = 'dc7e84bfda79164b7ecd8486985d3860' +\
'4febdc6740d20b3ac88f6ad82a4fb08d' +\
'71ab47a086e86eedf39d1c5bba97c408' +\
'0126141d67f37be8538f5a8be740e484'
key = '603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4'
iv = '000102030405060708090a0b0c0d0e0f'
key = unhexlify(key)
iv = unhexlify(iv)
plaintext = unhexlify(plaintext)
ciphertext = unhexlify(ciphertext)
cipher = AES.new(key, AES.MODE_OFB, iv)
self.assertEqual(cipher.encrypt(plaintext), ciphertext)
cipher = AES.new(key, AES.MODE_OFB, iv)
self.assertEqual(cipher.decrypt(ciphertext), plaintext)
cipher = AES.new(key, AES.MODE_OFB, iv)
self.assertEqual(cipher.encrypt(plaintext[:-8]), ciphertext[:-8])
cipher = AES.new(key, AES.MODE_OFB, iv)
self.assertEqual(cipher.decrypt(ciphertext[:-8]), plaintext[:-8])
示例10
def test_aes_128(self):
plaintext = '6bc1bee22e409f96e93d7e117393172a' +\
'ae2d8a571e03ac9c9eb76fac45af8e51' +\
'30c81c46a35ce411e5fbc1191a0a52ef' +\
'f69f2445df4f9b17ad2b417be66c3710'
ciphertext = '3b3fd92eb72dad20333449f8e83cfb4a' +\
'7789508d16918f03f53c52dac54ed825' +\
'9740051e9c5fecf64344f7a82260edcc' +\
'304c6528f659c77866a510d9c1d6ae5e'
key = '2b7e151628aed2a6abf7158809cf4f3c'
iv = '000102030405060708090a0b0c0d0e0f'
key = unhexlify(key)
iv = unhexlify(iv)
plaintext = unhexlify(plaintext)
ciphertext = unhexlify(ciphertext)
cipher = AES.new(key, AES.MODE_OFB, iv)
self.assertEqual(cipher.encrypt(plaintext), ciphertext)
cipher = AES.new(key, AES.MODE_OFB, iv)
self.assertEqual(cipher.decrypt(ciphertext), plaintext)
cipher = AES.new(key, AES.MODE_OFB, iv)
self.assertEqual(cipher.encrypt(plaintext[:-8]), ciphertext[:-8])
cipher = AES.new(key, AES.MODE_OFB, iv)
self.assertEqual(cipher.decrypt(ciphertext[:-8]), plaintext[:-8])
示例11
def test_aes_192(self):
plaintext = '6bc1bee22e409f96e93d7e117393172a' +\
'ae2d8a571e03ac9c9eb76fac45af8e51' +\
'30c81c46a35ce411e5fbc1191a0a52ef' +\
'f69f2445df4f9b17ad2b417be66c3710'
ciphertext = 'cdc80d6fddf18cab34c25909c99a4174' +\
'fcc28b8d4c63837c09e81700c1100401' +\
'8d9a9aeac0f6596f559c6d4daf59a5f2' +\
'6d9f200857ca6c3e9cac524bd9acc92a'
key = '8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b'
iv = '000102030405060708090a0b0c0d0e0f'
key = unhexlify(key)
iv = unhexlify(iv)
plaintext = unhexlify(plaintext)
ciphertext = unhexlify(ciphertext)
cipher = AES.new(key, AES.MODE_OFB, iv)
self.assertEqual(cipher.encrypt(plaintext), ciphertext)
cipher = AES.new(key, AES.MODE_OFB, iv)
self.assertEqual(cipher.decrypt(ciphertext), plaintext)
cipher = AES.new(key, AES.MODE_OFB, iv)
self.assertEqual(cipher.encrypt(plaintext[:-8]), ciphertext[:-8])
cipher = AES.new(key, AES.MODE_OFB, iv)
self.assertEqual(cipher.decrypt(ciphertext[:-8]), plaintext[:-8])
示例12
def test_aes_256(self):
plaintext = '6bc1bee22e409f96e93d7e117393172a' +\
'ae2d8a571e03ac9c9eb76fac45af8e51' +\
'30c81c46a35ce411e5fbc1191a0a52ef' +\
'f69f2445df4f9b17ad2b417be66c3710'
ciphertext = 'dc7e84bfda79164b7ecd8486985d3860' +\
'4febdc6740d20b3ac88f6ad82a4fb08d' +\
'71ab47a086e86eedf39d1c5bba97c408' +\
'0126141d67f37be8538f5a8be740e484'
key = '603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4'
iv = '000102030405060708090a0b0c0d0e0f'
key = unhexlify(key)
iv = unhexlify(iv)
plaintext = unhexlify(plaintext)
ciphertext = unhexlify(ciphertext)
cipher = AES.new(key, AES.MODE_OFB, iv)
self.assertEqual(cipher.encrypt(plaintext), ciphertext)
cipher = AES.new(key, AES.MODE_OFB, iv)
self.assertEqual(cipher.decrypt(ciphertext), plaintext)
cipher = AES.new(key, AES.MODE_OFB, iv)
self.assertEqual(cipher.encrypt(plaintext[:-8]), ciphertext[:-8])
cipher = AES.new(key, AES.MODE_OFB, iv)
self.assertEqual(cipher.decrypt(ciphertext[:-8]), plaintext[:-8])
示例13
def get_encrypted_data(self, secret, data):
data = data[27:]
header = data[:2]
salt = data[2:6]
iv = data[6:22]
encrypted_data = data[22:42]
if header != self.RECOVERY_TOKEN_HEADER:
raise Exception('Header mismatch')
key = self.get_key(secret, salt)
cipher = AES.new(key, AES.MODE_OFB, iv)
return cipher.decrypt(encrypted_data)
示例14
def decrypt(self, password):
"""decrypt "secret_secret" from the ini file with the given password.
This will return false if decryption did not seem to be successful.
After this menthod succeeded the application can access the secret"""
key = self.config.get_string("api", "secret_key")
sec = self.config.get_string("api", "secret_secret")
if sec == "" or key == "":
return self.S_NO_SECRET
hashed_pass = hashlib.sha512(password.encode("utf-8")).digest()
crypt_key = hashed_pass[:32]
crypt_ini = hashed_pass[-16:]
aes = AES.new(crypt_key, AES.MODE_OFB, crypt_ini)
try:
encrypted_secret = base64.b64decode(sec.strip().encode("ascii"))
self.secret = aes.decrypt(encrypted_secret).strip()
self.key = key.strip()
except ValueError:
return self.S_FAIL
# now test if we now have something plausible
try:
print("testing secret...")
# is it plain ascii? (if not this will raise exception)
# dummy = self.secret.decode("ascii")
# can it be decoded? correct size afterwards?
if len(base64.b64decode(self.secret)) != 64:
raise Exception("Decrypted secret has wrong size")
if not self.secret:
raise Exception("Unable to decrypt secret")
print("testing key...")
# key must be only hex digits and have the right size
# hex_key = self.key.replace("-", "").encode("ascii")
# if len(binascii.unhexlify(hex_key)) != 16:
# raise Exception("key has wrong size")
if not self.key:
raise Exception("Unable to decrypt key")
print("OK")
return self.S_OK
except Exception as exc:
# this key and secret do not work
self.secret = ""
self.key = ""
print("### Error occurred while testing the decrypted secret:")
print(" '%s'" % exc)
print(" This does not seem to be a valid API secret")
return self.S_FAIL
示例15
def des_encrypt(
self,
key: str,
iv: str = "0000000000000000",
mode: str = "CBC",
hex_key: bool = False,
hex_iv: bool = True,
):
"""Encrypt raw state with DES
DES is a previously dominant algorithm for encryption, and was published
as an official U.S. Federal Information Processing Standard (FIPS). It is
now considered to be insecure due to its small key size. DES uses a key
length of 8 bytes (64 bits).<br>Triple DES uses a key length of 24 bytes.
You can generate a password-based key using one of the KDF operations.
The Initialization Vector should be 8 bytes long. If not entered, it will
default to 8 null bytes. Padding: In CBC and ECB mode, PKCS#7 padding will be used.
Args:
key (str): Required. The secret key
iv (str, optional): IV for certain modes only. Defaults to '0000000000000000'.
mode (str, optional): Encryption mode. Defaults to 'CBC'.
hex_key (bool, optional): If the secret key is a hex string. Defaults to False.
hex_iv (bool, optional): If the IV is a hex string. Defaults to True.
Returns:
Chepy: The Chepy object.
Examples:
>>> Chepy("some data").des_encrypt("70617373776f7264", hex_key=True).o
b"1ee5cb52954b211d1acd6e79c598baac"
To encrypt using a differnt mode
>>> Chepy("some data").des_encrypt("password", mode="CTR").o
b"0b7399049b0267d93d"
"""
self.__check_mode(mode)
key, iv = self._convert_key(key, iv, hex_key, hex_iv)
if mode == "CBC":
cipher = DES.new(key, mode=DES.MODE_CBC, iv=iv)
self.state = cipher.encrypt(pad(self._convert_to_bytes(), 8))
return self
elif mode == "ECB":
cipher = DES.new(key, mode=DES.MODE_ECB)
self.state = cipher.encrypt(pad(self._convert_to_bytes(), 8))
return self
elif mode == "CTR":
cipher = DES.new(key, mode=DES.MODE_CTR, nonce=b"")
self.state = cipher.encrypt(self._convert_to_bytes())
return self
elif mode == "OFB":
cipher = DES.new(key, mode=DES.MODE_OFB, iv=iv)
self.state = cipher.encrypt(self._convert_to_bytes())
return self
示例16
def des_decrypt(
self,
key: str,
iv: str = "0000000000000000",
mode: str = "CBC",
hex_key: bool = False,
hex_iv: bool = True,
):
"""Decrypt raw state encrypted with DES.
DES is a previously dominant algorithm for encryption, and was published
as an official U.S. Federal Information Processing Standard (FIPS). It is
now considered to be insecure due to its small key size. DES uses a key
length of 8 bytes (64 bits).<br>Triple DES uses a key length of 24 bytes.
You can generate a password-based key using one of the KDF operations.
The Initialization Vector should be 8 bytes long. If not entered, it will
default to 8 null bytes. Padding: In CBC and ECB mode, PKCS#7 padding will be used.
Args:
key (str): Required. The secret key
iv (str, optional): IV for certain modes only. Defaults to '0000000000000000'.
mode (str, optional): Encryption mode. Defaults to 'CBC'.
hex_key (bool, optional): If the secret key is a hex string. Defaults to False.
hex_iv (bool, optional): If the IV is a hex string. Defaults to True.
Returns:
Chepy: The Chepy object.
Examples:
>>> Chepy("1ee5cb52954b211d1acd6e79c598baac").hex_to_str().des_decrypt("password").o
b"some data"
"""
self.__check_mode(mode)
key, iv = self._convert_key(key, iv, hex_key, hex_iv)
if mode == "CBC":
cipher = DES.new(key, mode=DES.MODE_CBC, iv=iv)
self.state = unpad(cipher.decrypt(self._convert_to_bytes()), 8)
return self
elif mode == "ECB":
cipher = DES.new(key, mode=DES.MODE_ECB)
self.state = unpad(cipher.decrypt(self._convert_to_bytes()), 8)
return self
elif mode == "CTR":
cipher = DES.new(key, mode=DES.MODE_CTR, nonce=b"")
self.state = cipher.decrypt(self._convert_to_bytes())
return self
elif mode == "OFB":
cipher = DES.new(key, mode=DES.MODE_OFB, iv=iv)
self.state = cipher.decrypt(self._convert_to_bytes())
return self
示例17
def triple_des_encrypt(
self,
key: str,
iv: str = "0000000000000000",
mode: str = "CBC",
hex_key: bool = False,
hex_iv: bool = True,
):
"""Encrypt raw state with Triple DES
Triple DES applies DES three times to each block to increase key size. Key:
Triple DES uses a key length of 24 bytes (192 bits).<br>DES uses a key length
of 8 bytes (64 bits).<br><br>You can generate a password-based key using one
of the KDF operations. IV: The Initialization Vector should be 8 bytes long.
If not entered, it will default to 8 null bytes. Padding: In CBC and ECB
mode, PKCS#7 padding will be used.
Args:
key (str): Required. The secret key
iv (str, optional): IV for certain modes only. Defaults to '0000000000000000'.
mode (str, optional): Encryption mode. Defaults to 'CBC'.
hex_key (bool, optional): If the secret key is a hex string. Defaults to False.
hex_iv (bool, optional): If the IV is a hex string. Defaults to True.
Returns:
Chepy: The Chepy object.
Examples:
>>> Chepy("some data").triple_des_encrypt("super secret password !!", mode="ECB").o
b"f8b27a0d8c837edc8fb00ea85f502fb4"
"""
self.__check_mode(mode)
key, iv = self._convert_key(key, iv, hex_key, hex_iv)
if mode == "CBC":
cipher = DES3.new(key, mode=DES3.MODE_CBC, iv=iv)
self.state = cipher.encrypt(pad(self._convert_to_bytes(), 8))
return self
elif mode == "ECB":
cipher = DES3.new(key, mode=DES3.MODE_ECB)
self.state = cipher.encrypt(pad(self._convert_to_bytes(), 8))
return self
elif mode == "CTR":
cipher = DES3.new(key, mode=DES3.MODE_CTR, nonce=b"")
self.state = cipher.encrypt(self._convert_to_bytes())
return self
elif mode == "OFB":
cipher = DES3.new(key, mode=DES3.MODE_OFB, iv=iv)
self.state = cipher.encrypt(self._convert_to_bytes())
return self
示例18
def triple_des_decrypt(
self,
key: str,
iv: str = "0000000000000000",
mode: str = "CBC",
hex_key: bool = False,
hex_iv: bool = True,
):
"""Decrypt raw state encrypted with DES.
Triple DES applies DES three times to each block to increase key size. Key:
Triple DES uses a key length of 24 bytes (192 bits).<br>DES uses a key length
of 8 bytes (64 bits).<br><br>You can generate a password-based key using one
of the KDF operations. IV: The Initialization Vector should be 8 bytes long.
If not entered, it will default to 8 null bytes. Padding: In CBC and ECB
mode, PKCS#7 padding will be used.
Args:
key (str): Required. The secret key
iv (str, optional): IV for certain modes only. Defaults to '0000000000000000'.
mode (str, optional): Encryption mode. Defaults to 'CBC'.
hex_key (bool, optional): If the secret key is a hex string. Defaults to False.
hex_iv (bool, optional): If the IV is a hex string. Defaults to True.
Returns:
Chepy: The Chepy object.
Examples:
>>> c = Chepy("f8b27a0d8c837edce87dd13a1ab41f96")
>>> c.hex_to_str()
>>> c.triple_des_decrypt("super secret password !!")
>>> c.o
b"some data"
"""
self.__check_mode(mode)
key, iv = self._convert_key(key, iv, hex_key, hex_iv)
if mode == "CBC":
cipher = DES3.new(key, mode=DES3.MODE_CBC, iv=iv)
self.state = unpad(cipher.decrypt(self._convert_to_bytes()), 8)
return self
elif mode == "ECB":
cipher = DES3.new(key, mode=DES3.MODE_ECB)
self.state = unpad(cipher.decrypt(self._convert_to_bytes()), 8)
return self
elif mode == "CTR":
cipher = DES3.new(key, mode=DES3.MODE_CTR, nonce=b"")
self.state = cipher.decrypt(self._convert_to_bytes())
return self
elif mode == "OFB":
cipher = DES3.new(key, mode=DES3.MODE_OFB, iv=iv)
self.state = cipher.decrypt(self._convert_to_bytes())
return self
示例19
def blowfish_encrypt(
self,
key: str,
iv: str = "0000000000000000",
mode: str = "CBC",
hex_key: bool = False,
hex_iv: bool = True,
):
"""Encrypt raw state with Blowfish
Blowfish is a symmetric-key block cipher designed in 1993 by
Bruce Schneier and included in a large number of cipher suites
and encryption products. AES now receives more attention.
IV: The Initialization Vector should be 8 bytes long.
Args:
key (str): Required. The secret key
iv (str, optional): IV for certain modes only. Defaults to '0000000000000000'.
mode (str, optional): Encryption mode. Defaults to 'CBC'.
hex_key (bool, optional): If the secret key is a hex string. Defaults to False.
hex_iv (bool, optional): If the IV is a hex string. Defaults to True.
Returns:
Chepy: The Chepy object.
Examples:
>>> Chepy("some data").blowfish_encrypt("password", mode="ECB").o
b"d9b0a79853f139603951bff96c3d0dd5"
"""
self.__check_mode(mode)
key, iv = self._convert_key(key, iv, hex_key, hex_iv)
if mode == "CBC":
cipher = Blowfish.new(key, mode=Blowfish.MODE_CBC, iv=iv)
self.state = cipher.encrypt(pad(self._convert_to_bytes(), 8))
return self
elif mode == "ECB":
cipher = Blowfish.new(key, mode=Blowfish.MODE_ECB)
self.state = cipher.encrypt(pad(self._convert_to_bytes(), 8))
return self
elif mode == "CTR":
cipher = Blowfish.new(key, mode=Blowfish.MODE_CTR, nonce=b"")
self.state = cipher.encrypt(self._convert_to_bytes())
return self
elif mode == "OFB":
cipher = Blowfish.new(key, mode=Blowfish.MODE_OFB, iv=iv)
self.state = cipher.encrypt(self._convert_to_bytes())
return self
