def test_signature_with_wrong_message_returns_false(self): w = Wallet() message = 'howdy' signature = w.sign(message) self.assertFalse(verify(w.verifying_key, 'hello', signature))
def test_signature_with_correct_message_returns_true(self): w = Wallet() message = 'howdy' signature = w.sign(message) self.assertTrue(verify(w.verifying_key, message, signature))
def test_no_txs_merklizes_and_signs_input_hash(self): tx_batch_1 = { 'transactions': [], 'timestamp': time.time(), 'input_hash': 'A' * 64 } work = [tx_batch_1] w = Wallet() exe = execution.SerialExecutor(executor=self.client.executor) results = exe.execute_work( driver=self.client.raw_driver, work=work, previous_block_hash='B' * 64, wallet=w, stamp_cost=20_000 ) self.assertTrue(verify(w.verifying_key, results[0]['input_hash'], results[0]['merkle_tree']['signature'])) h = hashlib.sha3_256() h.update(bytes.fromhex(results[0]['input_hash'])) self.assertEqual(h.hexdigest(), results[0]['merkle_tree']['leaves'][0])
def test_sign_works_properly(self): w = Wallet() tx = build_transaction( wallet=w, processor='b' * 64, stamps=123, nonce=0, contract='currency', function='transfer', kwargs={ 'amount': 123, 'to': 'jeff' } ) decoded = decode(tx) res = verify( w.verifying_key, encode(decoded['payload']), decoded['metadata']['signature'] ) self.assertTrue(res)
def test_signature_with_wrong_vk_returns_false(self): w = Wallet() message = 'howdy' signature = w.sign(message) a = Wallet() self.assertFalse(verify(a.verifying_key, message, signature))
async def process_message(self, msg): self.log.info(f'Received work from {msg["sender"][:8]}') # if msg['sender'] not in self.masters: # self.log.error(f'TX Batch received from non-master {msg["sender"][:8]}') # return shim = { 'transactions': [], 'timestamp': int(time.time()), 'signature': '0' * 128, 'input_hash': msg["sender"], 'sender': msg["sender"] } if not verify(vk=msg['sender'], msg=msg['input_hash'], signature=msg['signature']): self.log.error( f'Invalidly signed TX Batch received from master {msg["sender"][:8]}' ) return self.new_work[msg['sender']].append(shim) if int(time.time()) - msg['timestamp'] > self.expired_batch: self.log.error( f'Expired TX Batch received from master {msg["sender"][:8]}') return self.new_work[msg['sender']].append(shim) # Add padded! # Iterate and delete transactions from list that fail good_transactions = [] for tx in msg['transactions']: try: transaction.transaction_is_valid_no_stale( transaction=tx, expected_processor=msg['sender'], client=self.client, nonces=self.nonces, strict=False, timeout=self.expired_batch + self.tx_timeout) good_transactions.append(tx) except transaction.TransactionException as e: self.log.error(f'TX in batch has error: {type(e)}') if isinstance(e, transaction.TransactionTooManyPendingException): self.log.error(f'Adding {tx} to good txs.') good_transactions.append(tx) else: good_transactions.append(InvalidTX(tx, e)) # Replace transactions with ones that do not pass. msg['transactions'] = good_transactions self.new_work[msg['sender']].append(msg) self.log.info( f'{msg["sender"][:8]} has {len(self.new_work[msg["sender"]])} batches of work to do.' )
def check_tx_formatting(tx: dict, expected_processor: str): if not check_format(tx, rules.TRANSACTION_RULES): raise TransactionFormattingError if not wallet.verify(tx['payload']['sender'], encode(tx['payload']), tx['metadata']['signature']): raise TransactionSignatureInvalid if tx['payload']['processor'] != expected_processor: raise TransactionProcessorInvalid
def verify_proof(proof, pepper): # Proofs expire after a minute if not primatives.check_format(proof, rules.PROOF_MESSAGE_RULES): return False if int(time.time()) - proof['timestamp'] > PROOF_EXPIRY: return False message = [pepper, proof['ip'], proof['timestamp']] message_bytes = encode(message).encode() h = hashlib.sha3_256() h.update(message_bytes) return verify(proof['vk'], h.digest().hex(), proof['signature'])
def sbc_is_valid(self, sbc, sb_idx=0): if sbc['subblock'] != sb_idx: self.log.error(f'Subblock Contender[{sb_idx}] is out order.') return False # Make sure signer is in the delegates if len(sbc['transactions']) == 0: message = sbc['input_hash'] else: message = sbc['merkle_tree']['leaves'][0] valid_sig = verify(vk=sbc['signer'], msg=message, signature=sbc['merkle_tree']['signature']) if not valid_sig: self.log.error( f'Subblock Contender[{sb_idx}] from {sbc["signer"][:8]} has an invalid signature.' ) return False if len(sbc['merkle_tree']['leaves']) > 0: txs = [encode(tx).encode() for tx in sbc['transactions']] expected_tree = merklize(txs) # Missing leaves, etc if len(sbc['merkle_tree']['leaves']) != len(expected_tree) and len( sbc['transactions']) > 0: self.log.error('Merkle Tree Len mismatch') return False for i in range(len(expected_tree)): if expected_tree[i] != sbc['merkle_tree']['leaves'][i]: self.log.error( f'Subblock Contender[{sbc["subblock"]}] from {sbc["signer"][:8]} has an Merkle tree proof.' ) self.log.error(expected_tree[i]) self.log.error(txs[i]) return False self.log.info( f'Subblock[{sbc["subblock"]}] from {sbc["signer"][:8]} is valid.') return True
from lamden.crypto.wallet import Wallet, verify privkey = "01c4763eadd4285cc31fdd60dedb4fa7c68f29e325775dc7f7f082bbab9b5fc9" wallet = Wallet(privkey) # Let's sign this message and receive a signature message = "Some random string" signature = wallet.sign(message) print("signature", signature) # Output # ba32fcfa1b975f1572a1be21efa949d29f3a9e15e064d0e8d5f90eff596a204dd20ad8ca53161224ff62e97c147aba297f9ba8fd3a1eb8223c095cf6bcc85409 # Let's verify that the message was signed by my public address signature = "ba32fcfa1b975f1572a1be21efa949d29f3a9e15e064d0e8d5f90eff596a204dd20ad8ca53161224ff62e97c147aba297f9ba8fd3a1eb8223c095cf6bcc85409" was_it_me = verify(wallet.verifying_key, message, signature) print("was_it_me", was_it_me) # Output # was_it_me True