def test_script_hash(self): # Expected output taken from running: getHash(Buffer.from('abc', 'utf8')).toString('hex') # using https://github.com/CityOfZion/neon-wallet-react-native/blob/master/app/api/crypto/index.js expected_result = b'bb1be98c142444d7a56aa3981c3942a978e4dc33' result = Crypto.Default().Hash160(b'abc') self.assertEqual(expected_result, binascii.hexlify(result))
def ToScriptHash(self, address): """ Retrieve the script_hash based from an address. Args: address (str): a base58 encoded address. Raises: ValuesError: if an invalid address is supplied or the coin version is incorrect Exception: if the address string does not start with 'A' or the checksum fails Returns: UInt160: script hash. """ if len(address) == 34: if address[0] == 'A': data = b58decode(address) if data[0] != self.AddressVersion: raise ValueError('Not correct Coin Version') checksum = Crypto.Default().Hash256(data[:21])[:4] if checksum != data[21:]: raise Exception('Address format error') return UInt160(data=data[1:21]) else: raise Exception('Address format error') else: raise ValueError('Not correct Address, wrong length.')
def __init__(self, trigger_type, container, table, service, gas, testMode=False, exit_on_error=False): super(ApplicationEngine, self).__init__(container=container, crypto=Crypto.Default(), table=table, service=service, exit_on_error=exit_on_error) self.Trigger = trigger_type self.gas_amount = self.gas_free + gas.value self.testMode = testMode self._is_stackitem_count_strict = True
def execute_test(data: dict): global test_count, skipped_test_count for test in data['tests']: test_count += 1 # interop service service = InteropService.InteropService() # message provider script_container = None message = test.get("message", None) if message: script_container = MessageProvider(message) # prepare script table script_table = None # there are currently no tests that load a script table so I don't know the format or key value they'll use # create engine and run engine = ExecutionEngine(crypto=Crypto.Default(), service=service, container=script_container, table=script_table, exit_on_error=True) # TODO: should enforce 0x<data> rule in the JSON test case if test['script'].startswith('0x'): script = test['script'][2:] else: script = test['script'] try: script = binascii.unhexlify(script) except binascii.Error: print(f"Skipping test {data['category']}-{data['name']}, cannot read script data") test_count -= 1 skipped_test_count += 1 continue engine.LoadScript(script) steps = test.get('steps', None) if steps is None: continue for i, step in enumerate(steps): actions = step.get('actions', []) for action in actions: if action == "StepInto": engine.StepInto() elif action == "Execute": engine.Execute() elif action == "StepOver": raise ValueError("StepOver not supported!") elif action == "StepOut": raise ValueError("StepOut not supported!") test_name = test.get("name", "") msg = f"{data['category']}-{data['name']}-{test_name}-{i}" assert_result(engine, step['result'], msg)
def test_sign_and_verify_str(self): privkey = KeyPair.PrivateKeyFromWIF( "L44B5gGEpqEDRS9vVPz7QT35jcBG2r3CZwSwQ4fCewXAhAhqGVpP") keypair = KeyPair(privkey) hashdata = "74657374" keypair_signature = Crypto.Sign(hashdata, bytes(keypair.PrivateKey)) keypair_signature2 = Crypto.Default().Sign(hashdata, bytes(keypair.PrivateKey)) self.assertEqual(keypair_signature, keypair_signature2) # verify without unhexing verification_result = Crypto.VerifySignature("test", keypair_signature, keypair.PublicKey, unhex=False) verification_result2 = Crypto.Default().VerifySignature( "test", keypair_signature, keypair.PublicKey, unhex=False) self.assertEqual(verification_result, verification_result2) self.assertTrue(verification_result)
def test_sign_and_verify(self): privkey = KeyPair.PrivateKeyFromWIF( "L44B5gGEpqEDRS9vVPz7QT35jcBG2r3CZwSwQ4fCewXAhAhqGVpP") keypair = KeyPair(privkey) hashdata = b'aabbcc' keypair_signature = Crypto.Sign(hashdata, bytes(keypair.PrivateKey)) keypair_signature2 = Crypto.Default().Sign(hashdata, bytes(keypair.PrivateKey)) self.assertEqual(keypair_signature, keypair_signature2) verification_result = Crypto.VerifySignature(hashdata.decode('utf8'), keypair_signature, keypair.PublicKey) verification_result2 = Crypto.Default().VerifySignature( hashdata.decode('utf8'), keypair_signature, keypair.PublicKey) self.assertEqual(verification_result, verification_result2) self.assertTrue(verification_result) # verify with compressed key verification_result3 = Crypto.VerifySignature( hashdata.decode('utf8'), keypair_signature, binascii.unhexlify(keypair.PublicKey.encode_point(True))) self.assertTrue(verification_result3) # verify without unhexxing verification_result4 = Crypto.VerifySignature( binascii.unhexlify(hashdata), keypair_signature, binascii.unhexlify(keypair.PublicKey.encode_point(True)), unhex=False) self.assertTrue(verification_result4) # this should fail because the signature will not match the input data verification_result = Crypto.VerifySignature(b'aabb', keypair_signature, keypair.PublicKey) self.assertFalse(verification_result)
def Sign(verifiable, keypair): """ Sign the `verifiable` object with the private key from `keypair`. Args: verifiable: keypair (neo.Core.KeyPair): Returns: bool: True if successfully signed. False otherwise. """ prikey = bytes(keypair.PrivateKey) hashdata = verifiable.GetHashData() res = Crypto.Default().Sign(hashdata, prikey) return res
def SignMessage(self, message, script_hash): """ Sign a message with a specified script_hash. Args: message (str): a hex encoded message to sign script_hash (UInt160): a bytearray (len 20). Returns: str: the signed message """ keypair = self.GetKeyByScriptHash(script_hash) prikey = bytes(keypair.PrivateKey) res = Crypto.Default().Sign(message, prikey) return res, keypair.PublicKey
def Export(self): """ Export this KeyPair's private key in WIF format. Returns: str: The key in wif format """ data = bytearray(38) data[0] = 0x80 data[1:33] = self.PrivateKey[0:32] data[33] = 0x01 checksum = Crypto.Default().Hash256(data[0:34]) data[34:38] = checksum[0:4] b58 = base58.b58encode(bytes(data)) return b58.decode("utf-8")
def __init__(self, trigger_type, container, snapshot, gas, testMode=False, exit_on_error=True): super(ApplicationEngine, self).__init__(container=container, crypto=Crypto.Default(), table=snapshot, service=StateMachine(trigger_type, snapshot), exit_on_error=exit_on_error) self.gas_amount = self.gas_free + gas.value self.testMode = testMode self.snapshot = snapshot self._is_stackitem_count_strict = True self.debugger = None self.gas_consumed = 0 self.invocation_args = None
def AddrStrToScriptHash(address): """ Convert a public address to a script hash. Args: address (str): base 58 check encoded public address. Raises: ValueError: if the address length of address version is incorrect. Exception: if the address checksum fails. Returns: UInt160: """ data = b58decode(address) if len(data) != 25: raise ValueError('Not correct Address, wrong length.') if data[0] != settings.ADDRESS_VERSION: raise ValueError('Not correct Coin Version') checksum = Crypto.Default().Hash256(data[:21])[:4] if checksum != data[21:]: raise Exception('Address format error') return UInt160(data=data[1:21])
def setUp(self): self.engine = ExecutionEngine(crypto=Crypto.Default()) self.econtext = ExecutionContext(engine=self.engine)
def Add(self, script: bytearray) -> None: h = bytearray(Crypto.Default().Hash160(script)) h.reverse() self.data[binascii.hexlify(h)] = script
def setUp(self): self.engine = ExecutionEngine(crypto=Crypto.Default()) self.econtext = ExecutionContext(Script(self.engine.Crypto, b''), 0) self.engine.InvocationStack.PushT(self.econtext)
def setUp(self): self.engine = ExecutionEngine(crypto=Crypto.Default()) self.econtext = ExecutionContext(Script(self.engine.Crypto, b''), 0) self.engine.InvocationStack.PushT(self.econtext) snapshot = GetBlockchain()._db.createSnapshot() self.state_reader = StateReader(TriggerType.Application, snapshot)