def __bytes__(self):
if not self.data:
return compat_bytes(Bool(0))
else:
return compat_bytes(Bool(1)) + compat_bytes(
self.data) if compat_bytes(self.data) else compat_bytes(
Bool(0))
def encrypt(privkey, passphrase):
""" BIP0038 non-ec-multiply encryption. Returns BIP0038 encrypted privkey.
:param privkey: Private key
:type privkey: Base58
:param str passphrase: UTF-8 encoded passphrase for encryption
:return: BIP0038 non-ec-multiply encrypted wif key
:rtype: Base58
"""
privkeyhex = repr(privkey) # hex
addr = format(privkey.uncompressed.address, "BTC")
a = compat_bytes(addr, 'ascii')
salt = hashlib.sha256(hashlib.sha256(a).digest()).digest()[0:4]
if SCRYPT_MODULE == "scrypt":
if sys.version >= '3.0.0':
key = scrypt.hash(passphrase, salt, 16384, 8, 8)
else:
key = scrypt.hash(str(passphrase), str(salt), 16384, 8, 8)
elif SCRYPT_MODULE == "pylibscrypt":
key = scrypt.scrypt(compat_bytes(passphrase, "utf-8"), salt, 16384, 8,
8)
else:
raise ValueError("No scrypt module loaded")
(derived_half1, derived_half2) = (key[:32], key[32:])
aes = AES.new(derived_half2)
encrypted_half1 = _encrypt_xor(privkeyhex[:32], derived_half1[:16], aes)
encrypted_half2 = _encrypt_xor(privkeyhex[32:], derived_half1[16:], aes)
" flag byte is forced 0xc0 because Graphene only uses compressed keys "
payload = (b'\x01' + b'\x42' + b'\xc0' + salt + encrypted_half1 +
encrypted_half2)
" Checksum "
checksum = hashlib.sha256(hashlib.sha256(payload).digest()).digest()[:4]
privatekey = hexlify(payload + checksum).decode('ascii')
return Base58(privatekey)
def varint(n):
""" Varint encoding
"""
data = b''
while n >= 0x80:
data += compat_bytes([(n & 0x7f) | 0x80])
n >>= 7
data += compat_bytes([n])
return data
def compressed(self):
""" Derive compressed public key """
order = ecdsa.SECP256k1.generator.order()
p = ecdsa.VerifyingKey.from_string(compat_bytes(self),
curve=ecdsa.SECP256k1).pubkey.point
x_str = ecdsa.util.number_to_string(p.x(), order)
# y_str = ecdsa.util.number_to_string(p.y(), order)
compressed = hexlify(
compat_bytes(compat_chr(2 + (p.y() & 1)), 'ascii') +
x_str).decode('ascii')
return (compressed)
def get_private(self):
""" Derive private key from the brain key and the current sequence
number
"""
a = compat_bytes(self.account + self.role + self.password, 'utf8')
s = hashlib.sha256(a).digest()
return PrivateKey(hexlify(s).decode('ascii'))
def get_private(self):
""" Derive private key from the brain key and the current sequence
number
"""
encoded = "%s %d" % (self.brainkey, self.sequence)
a = compat_bytes(encoded, 'ascii')
s = hashlib.sha256(hashlib.sha512(a).digest()).digest()
return PrivateKey(hexlify(s).decode('ascii'))
def base58encode(hexstring):
byteseq = compat_bytes(hexstring, 'ascii')
byteseq = unhexlify(byteseq)
byteseq = compat_bytes(byteseq)
n = 0
leading_zeroes_count = 0
for c in byteseq:
n = n * 256 + c
if n == 0:
leading_zeroes_count += 1
res = bytearray()
while n >= 58:
div, mod = divmod(n, 58)
res.insert(0, BASE58_ALPHABET[mod])
n = div
else:
res.insert(0, BASE58_ALPHABET[n])
return (BASE58_ALPHABET[0:1] * leading_zeroes_count + res).decode('ascii')
def encode_memo(priv, pub, nonce, message, **kwargs):
""" Encode a message with a shared secret between Alice and Bob
:param PrivateKey priv: Private Key (of Alice)
:param PublicKey pub: Public Key (of Bob)
:param int nonce: Random nonce
:param str message: Memo message
:return: Encrypted message
:rtype: hex
"""
from bearbase import transactions
shared_secret = get_shared_secret(priv, pub)
aes, check = init_aes(shared_secret, nonce)
raw = compat_bytes(message, 'utf8')
" Padding "
BS = 16
if len(raw) % BS:
raw = _pad(raw, BS)
" Encryption "
cipher = hexlify(aes.encrypt(raw)).decode('ascii')
prefix = kwargs.pop("prefix", default_prefix)
s = OrderedDict([
("from", format(priv.pubkey, prefix)),
("to", format(pub, prefix)),
("nonce", nonce),
("check", check),
("encrypted", cipher),
("from_priv", repr(priv)),
("to_pub", repr(pub)),
("shared_secret", shared_secret),
])
tx = Memo(**s)
return "#" + base58encode(hexlify(compat_bytes(tx)).decode("ascii"))
def decode_memo(priv, message):
""" Decode a message with a shared secret between Alice and Bob
:param PrivateKey priv: Private Key (of Bob)
:param base58encoded message: Encrypted Memo message
:return: Decrypted message
:rtype: str
:raise ValueError: if message cannot be decoded as valid UTF-8
string
"""
" decode structure "
raw = base58decode(message[1:])
from_key = PublicKey(raw[:66])
raw = raw[66:]
to_key = PublicKey(raw[:66])
raw = raw[66:]
nonce = str(struct.unpack_from("<Q", unhexlify(raw[:16]))[0])
raw = raw[16:]
check = struct.unpack_from("<I", unhexlify(raw[:8]))[0]
raw = raw[8:]
cipher = raw
if repr(to_key) == repr(priv.pubkey):
shared_secret = get_shared_secret(priv, from_key)
elif repr(from_key) == repr(priv.pubkey):
shared_secret = get_shared_secret(priv, to_key)
else:
raise ValueError("Incorrect PrivateKey")
" Init encryption "
aes, checksum = init_aes(shared_secret, nonce)
" Check "
assert check == checksum, "Checksum failure"
" Encryption "
# remove the varint prefix (FIXME, long messages!)
message = cipher[2:]
message = aes.decrypt(unhexlify(compat_bytes(message, 'ascii')))
try:
return _unpad(message.decode('utf8'), 16)
except: # noqa FIXME(sneak)
raise ValueError(message)
def unicodify(self):
r = []
for s in self.data:
o = ord(s)
if o <= 7:
r.append("u%04x" % o)
elif o == 8:
r.append("b")
elif o == 9:
r.append("\t")
elif o == 10:
r.append("\n")
elif o == 11:
r.append("u%04x" % o)
elif o == 12:
r.append("f")
elif o == 13:
r.append("\r")
elif 13 < o < 32:
r.append("u%04x" % o)
else:
r.append(s)
return compat_bytes("".join(r), "utf-8")
def _unpad(s, BS):
count = int(struct.unpack('B', compat_bytes(s[-1], 'ascii'))[0])
if compat_bytes(s[-count::], 'ascii') == count * struct.pack('B', count):
return s[:-count]
return s
def __bytes__(self):
return compat_bytes(self.instance) # only yield instance
def __bytes__(self):
return compat_bytes(self.data)
def __bytes__(self):
""" Returns the raw private key """
return compat_bytes(self._wif)
def __bytes__(self):
b = b""
b += varint(len(self.data))
for e in self.data:
b += compat_bytes(e[0]) + compat_bytes(e[1])
return b
def __bytes__(self):
return varint(self.type_id) + compat_bytes(self.data)
def __bytes__(self):
""" Returns the raw public key (has length 33)"""
return compat_bytes(self._pk)
def __bytes__(self):
return compat_bytes(self.length) + b"".join(
[compat_bytes(a) for a in self.data])
def __bytes__(self):
# FIXME constraint data to self.length
d = unhexlify(compat_bytes(self.data, 'utf-8'))
return varint(len(d)) + d
def isempty(self):
if not self.data:
return True
return not bool(compat_bytes(self.data))
def __bytes__(self):
""" Returns the raw content of the ``Base58CheckEncoded`` address """
if self._address is None:
return compat_bytes(self.derivesha512address())
else:
return compat_bytes(self._address)
