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)