def sign(self, account=None, **kwargs): """ Sign a message with an account's memo key :param str account: (optional) the account that owns the bet (defaults to ``default_account``) :returns: the signed message encapsulated in a known format """ if not account: if "default_account" in config: account = config["default_account"] if not account: raise ValueError("You need to provide an account") # Data for message account = Account(account, bitshares_instance=self.bitshares) info = self.bitshares.info() meta = dict(timestamp=info["time"], block=info["head_block_number"], memokey=account["options"]["memo_key"], account=account["name"]) # wif key wif = self.bitshares.wallet.getPrivateKeyForPublicKey( account["options"]["memo_key"]) # signature message = self.message.strip() signature = hexlify( sign_message(SIGNED_MESSAGE_META.format(**locals()), wif)).decode("ascii") message = self.message return SIGNED_MESSAGE_ENCAPSULATED.format(MESSAGE_SPLIT=MESSAGE_SPLIT, **locals())
def test_sign_message_cryptography(self): if not ecdsa.CRYPTOGRAPHY_AVAILABLE: return ecdsa.SECP256K1_MODULE = "cryptography" signature = ecdsa.sign_message("Foobar", wif) pub_key_sig = ecdsa.verify_message("Foobar", signature) self.assertEqual(hexlify(pub_key_sig).decode("latin"), pub_key)
def test_sign_message_secp256k1(self): if not ecdsa.SECP256K1_AVAILABLE: return ecdsa.SECP256K1_MODULE = "secp256k1" signature = ecdsa.sign_message("Foobar", wif) pub_key_sig = ecdsa.verify_message("Foobar", signature) self.assertEqual(hexlify(pub_key_sig).decode("latin"), pub_key)
def build_tx(account, WIF): message = account signature = Signature(sign_message(message, WIF)) # signature2 = Signature(sign_message(account, WIF)) # logger.info(hexlify(signature2.data).decode('ascii')) d = {'account':account} d['signature'] = hexlify(signature.data).decode('ascii') return d
def build_tx(account, WIF): op = Tx(**{ 'account': account, }) message = bytes(op) digest = hashlib.sha256(message).digest() signature = Signature(sign_message(message, WIF)) d = op.json() d['signature'] = hexlify(signature.data).decode('ascii') return d
def test_sign_message(): signature = sign_message( "text text text", "5JCvGL2GVVpjDrKzbKWPHEvuwFs5HdEGwr4brp8RQiwrpEFcZNP") # assert(hexlify(signature) == b'2075625adc5f0a025fa5125e1f1a6493c2ad9798ec18afb49d4a1d9f741ccac16' # b'441cb10d240046e5cf3b7f10694b62c608047ec037b2ddaec053bdd1f5107c927') k = verify_message("text text text", signature) p = PublicKey(hexlify(k).decode('ascii')) assert (str(p) == "SCR5bgzuweaHx231escVuPVxgudSyUWdKAH7fKgxZfp3nKSirzFRa")
def sign(self, account=None, **kwargs): """ Sign a message with an account's memo key :param str account: (optional) the account that owns the bet (defaults to ``default_account``) :raises ValueError: If not account for signing is provided :returns: the signed message encapsulated in a known format """ if not account: if "default_account" in self.blockchain.config: account = self.blockchain.config["default_account"] if not account: raise ValueError("You need to provide an account") # Data for message account = self.account_class(account, blockchain_instance=self.blockchain) info = self.blockchain.info() meta = dict( timestamp=info["time"], block=info["head_block_number"], memokey=account["options"]["memo_key"], account=account["name"], ) # wif key wif = self.blockchain.wallet.getPrivateKeyForPublicKey( account["options"]["memo_key"]) # We strip the message here so we know for sure there are no trailing # whitespaces or returns message = self.message.strip() enc_message = self.SIGNED_MESSAGE_META.format(**locals()) # signature signature = hexlify(sign_message(enc_message, wif)).decode("ascii") self.signed_by_account = account self.signed_by_name = account["name"] self.meta = meta self.plain_message = message return self.SIGNED_MESSAGE_ENCAPSULATED.format( MESSAGE_SPLIT=self.MESSAGE_SPLIT, **locals())
def __init__(self, ip, port): self.stream = Buffer() self.s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.s.connect((ip, port)) raw_pk = self.s.recv(33) self.pk = GraphenePublicKey(raw_pk.hex()) sk = PrivateKey() point = self.pk.point() * int.from_bytes(bytes(sk), "big") x: int = point.x() raw_data = x.to_bytes(32, "big") self.shared_secret = sha512(raw_data).digest() key = sha256(self.shared_secret).digest() crc = cityhash.CityHash128(self.shared_secret) data = crc.to_bytes(16, "little") iv = data[8:16] + data[:8] self.s.sendall(bytes.fromhex(repr(sk.pubkey))) self.encryptor = AES.new(key, AES.MODE_CBC, iv) self.test = AES.new(key, AES.MODE_CBC, iv) self.decryptor = AES.new(key, AES.MODE_CBC, iv) self.worker_thread = threading.Thread(target=self.worker) self.worker_thread.start() self.send( 5006, { "user_agent": "Haruka Mock Client", "core_protocol_version": 106, "inbound_address": "0.0.0.0", "inbound_port": 0, "outbound_port": 0, "node_public_key": sk.pubkey, "signed_shared_secret": ecdsa.sign_message(self.shared_secret, str(sk)), "chain_id": bytes.fromhex( "4018d7844c78f6a6c41c6a552b898022310fc5dec06da467ee7905a8dad512c8" ), "user_data": { "platform": String("unknown") } })
async def sign(self, account=None, **kwargs): """ Sign a message with an account's memo key :param str account: (optional) the account that owns the bet (defaults to ``default_account``) :raises ValueError: If not account for signing is provided :returns: the signed message encapsulated in a known format """ if not account: if "default_account" in self.blockchain.config: account = self.blockchain.config["default_account"] if not account: raise ValueError("You need to provide an account") # Data for message account = await self.account_class(account, blockchain_instance=self.blockchain) # wif key wif = self.blockchain.wallet.getPrivateKeyForPublicKey( account["options"]["memo_key"]) payload = [ "from", account["name"], "key", account["options"]["memo_key"], "time", str(datetime.utcnow()), "text", self.message, ] enc_message = json.dumps(payload, separators=(",", ":")) # signature signature = hexlify(sign_message(enc_message, wif)).decode("ascii") return dict(signed=enc_message, payload=payload, signature=signature)
def sign(message, wifKeys): signature = ecdsa.sign_message(message, wifKeys) return signature
def test_sign_message(self): signature = ecdsa.sign_message("Foobar", wif) pub_key_sig = ecdsa.verify_message("Foobar", signature) self.assertEqual(hexlify(pub_key_sig).decode("latin"), pub_key)