def encrypt_binary(self, infile, outfile, buffer_size=2048, nonce=None):
""" Encrypt a binary file
:param str infile: input file name
:param str outfile: output file name
:param int buffer_size: write buffer size
:param str nonce: when not set, a random string is generated and used
"""
if not os.path.exists(infile):
raise ValueError("%s does not exists!" % infile)
if nonce is None:
nonce = str(random.getrandbits(64))
if isinstance(self.from_account, Account):
memo_wif = self.blockchain.wallet.getPrivateKeyForPublicKey(
self.from_account["memo_key"]
)
else:
memo_wif = self.from_account
if isinstance(self.to_account, Account):
pubkey = self.to_account["memo_key"]
else:
pubkey = self.to_account
if not memo_wif:
raise MissingKeyError("Memo key for %s missing!" % self.from_account["name"])
if not hasattr(self, 'chain_prefix'):
self.chain_prefix = self.blockchain.prefix
file_size = os.path.getsize(infile)
priv = PrivateKey(memo_wif)
pub = PublicKey(
pubkey,
prefix=self.chain_prefix
)
enc = BtsMemo.encode_memo(
priv,
pub,
nonce,
"beem/%s" % __version__,
prefix=self.chain_prefix
)
enc = unhexlify(base58decode(enc[1:]))
shared_secret = BtsMemo.get_shared_secret(priv, pub)
aes, check = BtsMemo.init_aes(shared_secret, nonce)
with open(outfile, 'wb') as fout:
fout.write(struct.pack('<Q', len(enc)))
fout.write(enc)
fout.write(struct.pack('<Q', file_size))
with open(infile, 'rb') as fin:
while True:
data = fin.read(buffer_size)
n = len(data)
if n == 0:
break
elif n % 16 != 0:
data += b' ' * (16 - n % 16) # <- padded with spaces
encd = aes.encrypt(data)
fout.write(encd)
def encrypt(self,
memo,
bts_encrypt=False,
return_enc_memo_only=False,
nonce=None):
""" Encrypt a memo
:param str memo: clear text memo message
:param bool return_enc_memo_only: When True, only the encoded memo is returned
:param str nonce: when not set, a random string is generated and used
:returns: encrypted memo
:rtype: dict
"""
if not memo:
return None
if nonce is None:
nonce = str(random.getrandbits(64))
if isinstance(self.from_account, Account):
memo_wif = self.blockchain.wallet.getPrivateKeyForPublicKey(
self.from_account["memo_key"])
memo_wif = PrivateKey(memo_wif)
else:
memo_wif = self.from_account
if isinstance(self.to_account, Account):
pubkey = self.to_account["memo_key"]
else:
pubkey = self.to_account
if not memo_wif:
raise MissingKeyError("Memo key for %s missing!" %
self.from_account["name"])
if not hasattr(self, 'chain_prefix'):
self.chain_prefix = self.blockchain.prefix
if bts_encrypt:
enc = BtsMemo.encode_memo_bts(
PrivateKey(memo_wif),
PublicKey(pubkey, prefix=self.chain_prefix), nonce, memo)
return {
"message": enc,
"nonce": nonce,
"from": str(PrivateKey(memo_wif).pubkey),
"to": str(pubkey)
}
else:
enc = BtsMemo.encode_memo(PrivateKey(memo_wif),
PublicKey(pubkey,
prefix=self.chain_prefix),
nonce,
memo,
prefix=self.chain_prefix)
if return_enc_memo_only:
return enc
return {
"message": enc,
"from": str(PrivateKey(memo_wif).pubkey),
"to": str(pubkey)
}
def test_encrypt(self):
for memo in test_cases:
enc = encode_memo(PrivateKey(memo["wif"]),
PublicKey(memo["to"], prefix="GPH"),
memo["nonce"],
memo["plain"],
prefix="GPH")
self.assertEqual(memo["message"], enc)
def encrypt(self, memo, bts_encrypt=False):
""" Encrypt a memo
:param str memo: clear text memo message
:returns: encrypted memo
:rtype: str
"""
if not memo:
return None
nonce = str(random.getrandbits(64))
memo_wif = self.steem.wallet.getPrivateKeyForPublicKey(
self.from_account["memo_key"]
)
if not memo_wif:
raise MissingKeyError("Memo key for %s missing!" % self.from_account["name"])
if not hasattr(self, 'chain_prefix'):
self.chain_prefix = self.steem.prefix
if bts_encrypt:
enc = BtsMemo.encode_memo_bts(
PrivateKey(memo_wif),
PublicKey(
self.to_account["memo_key"],
prefix=self.chain_prefix
),
nonce,
memo
)
return {
"message": enc,
"nonce": nonce,
"from": self.from_account["memo_key"],
"to": self.to_account["memo_key"]
}
else:
enc = BtsMemo.encode_memo(
PrivateKey(memo_wif),
PublicKey(
self.to_account["memo_key"],
prefix=self.chain_prefix
),
nonce,
memo,
prefix=self.chain_prefix
)
return {
"message": enc,
"from": self.from_account["memo_key"],
"to": self.to_account["memo_key"]
}
def test_encrypt_decrypt(self):
base58 = u'#HU6pdQ4Hh8cFrDVooekRPVZu4BdrhAe9RxrWrei2CwfAApAPdM4PT5mSV9cV3tTuWKotYQF6suyM4JHFBZz4pcwyezPzuZ2na7uwhRcLqFotsqxWRBpaXkNks2QCnYLS8'
text = u'#爱'
nonce = u'1462976530069648'
wif = str(PasswordKey("", "", role="", prefix="STM").get_private_key())
private_key = PrivateKey(wif=wif, prefix="STM")
public_key = private_key.pubkey
cypertext = encode_memo(private_key,
public_key,
nonce,
text,
prefix="STM")
self.assertEqual(cypertext, base58)
plaintext = decode_memo(private_key, cypertext)
self.assertEqual(plaintext, text)