async def test_transfer_from(self): sdk.rpc.connect_to_localhost() b58_from_address = acct1.get_address_base58() b58_recv_address = acct2.get_address_base58() ong = sdk.native_vm.aio_ong() tx_hash = await ong.transfer_from(acct2, b58_from_address, b58_recv_address, 1, acct2, 500, 20000) self.assertEqual(64, len(tx_hash)) await asyncio.sleep(randint(14, 20)) event = await sdk.aio_rpc.get_contract_event_by_tx_hash(tx_hash) notify = Event.get_notify_by_contract_address(event, ong.contract_address) self.assertEqual(2, len(notify))
def main(args): AB, BA = Pipe(True) AE, EA = Pipe(True) BE, EB = Pipe(True) KEY = random.randint(1, 254) alice = Process(target=Alice, args=(AB, AE, KEY, args)) bob = Process(target=Bob, args=(BA, BE, KEY, args)) eva = Process(target=Eva, args=(EA, EB, args)) alice.start() bob.start() eva.start() alice.join() bob.join() eva.join()
def Bob(alice, args): global NAME NAME = "Bob" A, C, prime = alice.recv() H = alice.recv() print(log("Получены Hi")) B = [] N = alice.recv() r = set() while len(r) != args.n: r.add(random.randint(2, N // 2)) r = list(r) random.shuffle(r) r = r[:20] Z = [pow(i, 2, N) for i in r] print( log("Сгенерировано {} Z=r^2 (mod N) квадратичных вычетов".format( args.n))) alice.send(Z) rb = alice.recv() B = [1 if rb[i] == r[i] else 0 for i in range(args.n)] K = -1 for i in range(args.n): if B[i]: K = i break print(log("На основе ответов Алисы сгенерированы биты B")) alice.send(B) alice.send(r) if alice.recv(): return M = alice.recv() print(log("Начинаем проверку утверждений")) print(log("если Bi = 0, то A^Mi = Hi (mod prime)")) print(log("если Bi = 1, то A^Mi = Hi*Hj^-1 (mod prime)")) ANS = [] for i in range(args.n): if B[i]: ANS.append( pow(A, M[i], prime) == ((H[i] * reverse(H[K], prime)) % prime)) else: ANS.append(pow(A, M[i], prime) == (H[i] % prime)) print(log("ANS: {}".format(ANS))) Z = alice.recv() FINAL = (pow(A, Z, prime) == (C * reverse(H[K], prime)) % prime) if False not in ANS and FINAL: print( log("FINAL={} Я уверен что Алиса знает X с вероятностью {:03f}". format(FINAL, 1 - 1 / (2**args.n))))
async def test_transfer(self): oep4 = sdk.neo_vm.aio_oep4() oep4.hex_contract_address = contract_address from_acct = acct1 b58_to_address = acct2.get_address_base58() value = 10 tx_hash = await oep4.transfer(from_acct, b58_to_address, value, from_acct, 500, 20000000) self.assertEqual(64, len(tx_hash)) await asyncio.sleep(randint(14, 20)) notify = await oep4.query_transfer_event(tx_hash) self.assertEqual('transfer', notify['States'][0]) self.assertEqual(from_acct.get_address_base58(), notify['States'][1]) self.assertEqual(b58_to_address, notify['States'][2]) self.assertEqual(value, notify['States'][3])
def ecdsa_test(): a = params["A"] b = params["B"] prime = params["Prime"] q = params["Order"] A = params["Gener"] d = crypto_random.randint(0, q) # Private key B = point_multiply(d, A, prime, a) k_pub = (prime, a, b, q, A, B) k_e = crypto_random.randint(0, q) # secret ephemeral key R = point_multiply(k_e, A, prime, a) r = R[0] h_m = 0x2CF24DBA5FB0A30E26E83B2AC5B9E29E1B161E5C1FA7425E73043362938B9824 s = ((h_m + (d * r) % q) * inv_mod(k_e, q)) % q # Verify assert (s > 1) assert (s < q - 1) w = inv_mod(s, q) % q u1 = (w * h_m) % q u2 = (w * r) % q P1 = point_multiply(u1, A, prime, a) P2 = point_multiply(u2, B, prime, a) P = point_add(P1, P2, prime, a) print(R[1]) print(r) print(P[0]) print(P[1]) print(s) print(P == r) # This should be true, but it isn't...
def test_init(self): contract_address = '1ddbb682743e9d9e2b71ff419e97a9358c5c4ee9' oep4 = sdk.neo_vm.oep4() oep4.hex_contract_address = contract_address private_key = '523c5fcf74823831756f0bcb3634234f10b3beb1c05595058534577752ad2d9f' acct = Account(private_key, SignatureScheme.SHA256withECDSA) gas_limit = 20000000 gas_price = 500 tx_hash = oep4.init(acct, acct1, gas_limit, gas_price) self.assertEqual(len(tx_hash), 64) time.sleep(randint(6, 10)) notify = sdk.rpc.get_smart_contract_event_by_tx_hash( tx_hash)['Notify'][0] self.assertEqual('Already initialized!', bytes.fromhex(notify['States']).decode())
def test_verify_signature(self): identity = sdk.wallet_manager.create_identity(password) ctrl_acct = sdk.wallet_manager.get_control_account_by_index(identity.did, 0, password) did = sdk.native_vm.did() tx_hash = did.registry_did(identity.did, ctrl_acct, acct3, self.gas_price, self.gas_limit) self.assertEqual(64, len(tx_hash)) time.sleep(randint(10, 15)) event = sdk.default_network.get_contract_event_by_tx_hash(tx_hash) hex_contract_address = did.contract_address notify = Event.get_notify_by_contract_address(event, hex_contract_address) self.assertEqual(hex_contract_address, notify['ContractAddress']) self.assertEqual('Register', notify['States'][0]) self.assertEqual(identity.did, notify['States'][1]) private_key = utils.get_random_bytes(32) public_key = Signature.ec_get_public_key_by_private_key(private_key, Curve.P256) new_ctrl_acct = Account(private_key) hex_new_public_key = public_key.hex() tx_hash = did.add_public_key(identity.did, ctrl_acct, hex_new_public_key, acct4, self.gas_price, self.gas_limit) time.sleep(randint(10, 15)) event = sdk.default_network.get_contract_event_by_tx_hash(tx_hash) notify = Event.get_notify_by_contract_address(event, hex_contract_address) self.assertIn('PublicKey', notify['States']) self.assertIn('add', notify['States']) self.assertIn(identity.did, notify['States']) self.assertIn(hex_new_public_key, notify['States']) result = did.verify_signature(identity.did, 1, ctrl_acct) self.assertTrue(result) result = did.verify_signature(identity.did, 2, ctrl_acct) self.assertFalse(result) result = did.verify_signature(identity.did, 1, new_ctrl_acct) self.assertFalse(result) result = did.verify_signature(identity.did, 2, new_ctrl_acct) self.assertTrue(result)
async def test_transfer_from(self): oep4 = sdk.neo_vm.aio_oep4() oep4.hex_contract_address = contract_address b58_from_address = acct1.get_address_base58() b58_to_address = acct3.get_address_base58() value = 1 tx_hash = await oep4.transfer_from(acct2, b58_from_address, b58_to_address, value, acct1, 500, 20000000) self.assertEqual(64, len(tx_hash)) await asyncio.sleep(randint(14, 20)) event = await oep4.query_transfer_from_event(tx_hash) self.assertEqual(contract_address, event.get('ContractAddress', '')) self.assertEqual('transfer', event['States'][0]) self.assertEqual(b58_from_address, event['States'][1]) self.assertEqual(b58_to_address, event['States'][2]) self.assertEqual(value, event['States'][3])
def _generate_b(r): e = 0 d = 0 some = True while(some == True): e = randint(1,r-1) if (GCD(e,r)==1): d = inverse(e,r) if ((e*d)%r == 1): some = False break print("b = ", e) print("b_1 = ", d) return e, d
async def test_approve(self): oep4 = sdk.neo_vm.aio_oep4() oep4.hex_contract_address = contract_address b58_spender_address = acct2.get_address_base58() amount = 10 tx_hash = await oep4.approve(acct1, b58_spender_address, amount, acct1, 500, 20000000) self.assertEqual(len(tx_hash), 64) await asyncio.sleep(randint(14, 20)) event = await oep4.query_approve_event(tx_hash) self.assertEqual(contract_address, event.get('ContractAddress', '')) states = event['States'] self.assertEqual('approval', states[0]) self.assertEqual(acct1.get_address_base58(), states[1]) self.assertEqual(b58_spender_address, states[2]) self.assertEqual(amount, states[3])
def test_transfer(self): oep4 = sdk.neo_vm.oep4() oep4.hex_contract_address = self.contract_address from_acct = acct1 b58_to_address = acct2.get_address_base58() value = 10 tx_hash = oep4.transfer(from_acct, b58_to_address, value, from_acct, self.gas_price, self.gas_limit) self.assertEqual(64, len(tx_hash)) time.sleep(randint(10, 15)) notify = oep4.query_transfer_event(tx_hash) self.assertEqual('transfer', notify['States'][0]) self.assertEqual(from_acct.get_address_base58(), notify['States'][1]) self.assertEqual(b58_to_address, notify['States'][2]) self.assertEqual(value, notify['States'][3])
async def test_transfer(self): amount = 1 ont = sdk.native_vm.aio_ont() tx_hash = await ont.transfer(acct2, acct1.get_address(), amount, acct4, self.gas_price, self.gas_limit) await asyncio.sleep(randint(14, 20)) event = await sdk.aio_rpc.get_contract_event_by_tx_hash(tx_hash) notify = Event.get_notify_by_contract_address(event, ont.contract_address) self.assertEqual('transfer', notify['States'][0]) self.assertEqual(acct2.get_address_base58(), notify['States'][1]) self.assertEqual(acct1.get_address_base58(), notify['States'][2]) self.assertEqual(amount, notify['States'][3]) notify = Event.get_notify_by_contract_address(event, sdk.native_vm.aio_ong().contract_address) self.assertEqual('transfer', notify['States'][0]) self.assertEqual(acct4.get_address_base58(), notify['States'][1]) self.assertEqual(self.gas_price * self.gas_limit, notify['States'][3])
async def test_transfer_from_tx(self): acct2_b58_address = acct2.get_address_base58() tx_hash = await sdk.native_vm.aio_ont().transfer_from( acct2, acct1.get_address(), acct2_b58_address, 1, acct2, self.gas_price, self.gas_limit) self.assertEqual(64, len(tx_hash)) await asyncio.sleep(randint(14, 20)) event = await sdk.aio_rpc.get_contract_event_by_tx_hash(tx_hash) notify = Event.get_notify_by_contract_address( event, sdk.native_vm.aio_ont().contract_address) self.assertEqual('transfer', notify['States'][0]) self.assertEqual(acct1.get_address_base58(), notify['States'][1]) self.assertEqual(acct2.get_address_base58(), notify['States'][2]) self.assertEqual(1, notify['States'][3])
def private_equality_test(self, other): '''Returns an enciphered 1 if the two are the self. Otherwise returns an enciphered random number. https://crypto.stackexchange.com/questions/9527/how-does-an-oblivious-test-of-plaintext-equality-work ''' assert (self.key.p == other.key.p) assert (self.key.g == other.key.g) assert (self.key.y == other.key.y) other_c1_inv = pow(other.c1, self.key.p - 2, self.key.p) other_c2_inv = pow(other.c2, self.key.p - 2, self.key.p) new_c1 = (self.c1 * other_c1_inv) % self.key.p new_c2 = (self.c2 * other_c2_inv) % self.key.p z = randint(2, int(key.p - 1)) # To blind the ciphertext new_c1_z = pow(new_c1, Integer(z), self.key.p) new_c2_z = pow(new_c2, Integer(z), self.key.p) return CipherText(self.key, new_c1_z, new_c2_z)
def test_list(self): hex_contract_address = '6690b6638251be951dded8c537678200a470c679' list_msg = [1, 10, 1024, [1, 10, 1024, [1, 10, 1024]]] func = InvokeFunction('testList') func.set_params_value(list_msg) tx_hash = sdk.rpc.send_neo_vm_transaction(hex_contract_address, None, acct1, gas_limit, gas_price, func, False) time.sleep(randint(6, 10)) event = sdk.rpc.get_smart_contract_event_by_tx_hash(tx_hash) states = ContractEventParser.get_states_by_contract_address( event, hex_contract_address) states[0] = ContractDataParser.to_utf8_str(states[0]) self.assertEqual('testMsgList', states[0]) states[1] = ContractDataParser.to_int_list(states[1]) self.assertEqual(list_msg, states[1])
def test_get_account_by_address(self): test_id = "test_ont_id" wallet = WalletData(default_id=test_id) size = 10 address_list = list() for i in range(size): address = randint(0, 1000000000) acct = AccountData(b58_address=address) wallet.add_account(acct) address_list.append(address) self.assertEqual(len(wallet.accounts), i + 1) for i in range(size * 2): rand_address = choice(address_list) acct = wallet.get_account_by_b58_address(rand_address) self.assertEqual(rand_address, acct.b58_address)
def test_list(self): hex_contract_address = '6690b6638251be951dded8c537678200a470c679' list_msg = [1, 10, 1024, [1, 10, 1024, [1, 10, 1024]]] func = InvokeFunction('testList') func.set_params_value(list_msg) tx_hash = self.send_tx(hex_contract_address, None, acct1, func) if len(tx_hash) == 0: return time.sleep(randint(10, 15)) event = sdk.rpc.get_contract_event_by_tx_hash(tx_hash) states = Event.get_states_by_contract_address(event, hex_contract_address) states[0] = Data.to_utf8_str(states[0]) self.assertEqual('testMsgList', states[0]) states[1] = Data.to_int_list(states[1]) self.assertEqual(list_msg, states[1])
def test_transfer(self): sdk.rpc.connect_to_test_net() b58_to_address = acct1.get_address_base58() try: tx_hash = sdk.native_vm.asset().transfer('ont', acct2, b58_to_address, 1, acct4, 20000, 500) except SDKException as e: self.assertIn('balance insufficient', e.args[1]) return time.sleep(randint(7, 12)) event = sdk.rpc.get_smart_contract_event_by_tx_hash(tx_hash) self.assertEqual('0100000000000000000000000000000000000000', event['Notify'][0]['ContractAddress']) self.assertEqual('0200000000000000000000000000000000000000', event['Notify'][1]['ContractAddress'])
def test_remove_account(self): test_id = "test_ont_id" wallet = WalletData(default_id=test_id) size = 10 address_list = list() for i in range(size): address = randint(0, 1000000000) acct = AccountData(b58_address=address) wallet.add_account(acct) address_list.append(address) self.assertEqual(len(wallet.accounts), i + 1) for i in range(size): rand_address = choice(address_list) wallet.remove_account(rand_address) address_list.remove(rand_address) self.assertEqual(len(wallet.accounts), size - i - 1)
def merge_bytearray_and_wav(input_bytearray, wav_bytearray): cf = 0 out_bytearray = bytearray() len_in = len(input_bytearray) pc = max(len_in // 224, 1) cnt = 0 for i in range(0, len_in): current_byte = input_bytearray[i] current_chunks = byte_to_2_bit_chunks(current_byte) #print(current_chunks) # Here we are splitting a byte into four 2-bit chunks. As WAVs are little-endian, # and 16 bit per channel per sample, we must interleave the storage. The program # will store one byte in two 16-bit stereo frames (one byte per eight bytes). # This collects each byte in the original wav. b1, b2, b3, b4, b5, b6, b7, b8 = wav_bytearray[i * 8], wav_bytearray[ (i * 8) + 1], wav_bytearray[(i * 8) + 2], wav_bytearray[ (i * 8) + 3], wav_bytearray[(i * 8) + 4], wav_bytearray[ (i * 8) + 5], wav_bytearray[(i * 8) + 6], wav_bytearray[(i * 8) + 7] # This removes the last two bits and stores the needed info there. b1 &= 0b11111100 b1 |= current_chunks[0] b3 &= 0b11111100 b3 |= current_chunks[1] b5 &= 0b11111100 b5 |= current_chunks[2] b7 &= 0b11111100 b7 |= current_chunks[3] #print(b1&0b11,b3&0b11,b5&0b11,b7&0b11) #print(b1, b2, b3, b4, b5, b6, b7, b8) # This reassembles the WAV. out_bytearray.extend(bytes([b1, b2, b3, b4, b5, b6, b7, b8])) cpos = (len_in * 8) pc = max((len(wav_bytearray) - cpos) // 224, 1) # Most times, the file won't fit exactly into the WAV. So we must fill out that # space, to avoid creating a noticeable difference that possibly leaks the file # length, or makes the steganography more obvious. print("WAV PADDING REQUIRED:", len(wav_bytearray) - cpos) while cpos < len(wav_bytearray): if cpos % 2 == 0: out_bytearray.append((wav_bytearray[cpos] & 0b11111100) | random.randint(0, 3)) else: out_bytearray.append(wav_bytearray[cpos]) cpos += 1 return out_bytearray
def good_parameters(): p, q = getPrimePair() n = p * q f_n = (p - 1) * (q - 1) while (True): e = randint(1, f_n - 1) if (GCD(e, f_n) == 1): d = inverse(e, f_n) if 36 * pow(d, 4) > n: break print("p = {}".format(p)) print("q = {}".format(q)) print("n = {}".format(n)) print("e = {}".format(e)) print("d = {}".format(d))
def __post(self, method, b58_address: str or None, pwd: str or None, params): header = {'Content-type': 'application/json'} payload = dict(qid=str(randint(0, maxsize)), method=method, params=params) if isinstance(b58_address, str): payload['account'] = b58_address if isinstance(pwd, str): payload['pwd'] = pwd try: response = requests.post(self.__url, json=payload, headers=header, timeout=10) except requests.exceptions.MissingSchema as e: raise SDKException(ErrorCode.connect_err(e.args[0])) from None except requests.exceptions.ConnectTimeout: raise SDKException( ErrorCode.other_error(''.join(['ConnectTimeout: ', self.__url]))) from None except requests.exceptions.ConnectionError: raise SDKException( ErrorCode.other_error(''.join( ['ConnectionError: ', self.__url]))) from None except requests.exceptions.ReadTimeout: raise SDKException( ErrorCode.other_error(''.join(['ReadTimeout: ', self.__url]))) from None try: content = response.content.decode('utf-8') except Exception as e: raise SDKException(ErrorCode.other_error(e.args[0])) from None if response.status_code != 200: raise SDKException(ErrorCode.other_error(content)) try: content = json.loads(content) except json.decoder.JSONDecodeError as e: raise SDKException(ErrorCode.other_error(e.args[0])) from None if content['error_code'] != 0: if content['error_info'] != '': raise SDKException(ErrorCode.other_error( content['error_info'])) else: raise SDKException(ErrorCode.other_error(content['result'])) return content
def test_send_transfer(self): sdk.rpc.connect_to_test_net() asset = sdk.native_vm.asset() from_acct = acct2 payer = acct4 b58_to_address = acct1.get_address_base58() amount = 1 gas_price = 500 gas_limit = 20000 try: tx_hash = asset.send_transfer('ont', from_acct, b58_to_address, amount, payer, gas_limit, gas_price) except SDKException as e: self.assertIn('balance insufficient', e.args[1]) return time.sleep(randint(6, 10)) event = sdk.rpc.get_smart_contract_event_by_tx_hash(tx_hash) self.assertEqual('0100000000000000000000000000000000000000', event['Notify'][0]['ContractAddress']) self.assertEqual('0200000000000000000000000000000000000000', event['Notify'][1]['ContractAddress'])
def generate_encrypt_aes_key(public_key: bytes): if not isinstance(public_key, bytes): raise SDKException(ErrorCode.other_error('the type of public key should be bytes.')) if len(public_key) != 33: raise SDKException(ErrorCode.other_error('the length of public key should be 33 bytes.')) if not (public_key.startswith(b'\x02') or public_key.startswith(b'\x03')): raise SDKException(ErrorCode.other_error('Invalid public key.')) public_key = ECIES.__uncompress_public_key(public_key) r = randint(1, NIST256p.order) g_tilde = r * NIST256p.generator h_tilde = r * VerifyingKey.from_string(string=public_key, curve=NIST256p).pubkey.point str_g_tilde_x = number_to_string(g_tilde.x(), NIST256p.order) str_g_tilde_y = number_to_string(g_tilde.y(), NIST256p.order) encode_g_tilde = b''.join([b'\x04', str_g_tilde_x, str_g_tilde_y]) str_h_tilde_x = number_to_string(h_tilde.x(), NIST256p.order) seed = b''.join([encode_g_tilde, str_h_tilde_x]) aes_key = pbkdf2(seed, 32) return aes_key, encode_g_tilde
def run(self): assert self.outbox is not None self.KA = randint(0, 1 << 10) * self.N # KA = 0 mod N self.outbox.put((self.mel, self.KA)) salt, B = self.inbox.get() #u = int.from_bytes(SHA256.new(int_to_bytes(self.KA)+int_to_bytes(B)).digest(), 'big') # using the salt, retrieve the server db entry key #Kx = int.from_bytes(SHA256.new(salt+self.pwd).digest(), 'big') #KX = pow(self.g, Kx, self.N) #sec = pow(B-self.k*KX, self.Ka+u*Kx, self.N) sec = 0 key = SHA256.new(int_to_bytes(sec)).digest() print('Client: key', key.hex()) mac = HMAC.new(key, salt, SHA256).digest() self.outbox.put(mac) ok = self.inbox.get() assert ok == b'OK' print('Client: ok, done')
def test_oep4_transfer_multi(self): hex_contract_address = '1ddbb682743e9d9e2b71ff419e97a9358c5c4ee9' bytes_from_address1 = acct1.get_address().to_bytes() bytes_to_address1 = acct2.get_address().to_bytes() value1 = 2 transfer1 = [bytes_from_address1, bytes_to_address1, value1] bytes_from_address2 = acct2.get_address().to_bytes() bytes_to_address2 = acct3.get_address().to_bytes() value2 = 1 transfer2 = [bytes_from_address2, bytes_to_address2, value2] func = InvokeFunction('transferMulti') func.set_params_value(transfer1, transfer2) try: tx_hash = sdk.rpc.send_neo_vm_transaction(hex_contract_address, acct1, acct2, gas_limit, gas_price, func, False) except SDKException as e: self.assertIn('already in the tx pool', e.args[1]) return time.sleep(randint(6, 10)) event = sdk.rpc.get_smart_contract_event_by_tx_hash(tx_hash) states_list = ContractEventParser.get_states_by_contract_address( event, hex_contract_address) states_list[0][0] = ContractDataParser.to_utf8_str(states_list[0][0]) self.assertEqual('transfer', states_list[0][0]) states_list[0][1] = ContractDataParser.to_b58_address( states_list[0][1]) self.assertEqual(acct1.get_address().b58encode(), states_list[0][1]) states_list[0][2] = ContractDataParser.to_b58_address( states_list[0][2]) self.assertEqual(acct2.get_address().b58encode(), states_list[0][2]) states_list[0][3] = ContractDataParser.to_int(states_list[0][3]) self.assertEqual(value1, states_list[0][3]) states_list[1][0] = ContractDataParser.to_utf8_str(states_list[1][0]) self.assertEqual('transfer', states_list[1][0]) states_list[1][1] = ContractDataParser.to_b58_address( states_list[1][1]) self.assertEqual(acct2.get_address().b58encode(), states_list[1][1]) states_list[1][2] = ContractDataParser.to_b58_address( states_list[1][2]) self.assertEqual(acct3.get_address().b58encode(), states_list[1][2]) states_list[1][3] = ContractDataParser.to_int(states_list[1][3]) self.assertEqual(value2, states_list[1][3])
def test_transfer(self): amount = 1 gas = sdk.native_vm.gas() tx_hash = gas.transfer(acct1, acct2.get_address(), amount, acct4, self.gas_price, self.gas_limit) time.sleep(randint(14, 20)) event = sdk.default_network.get_contract_event_by_tx_hash(tx_hash) notify = Event.get_notify_by_contract_address(event, gas.contract_address) self.assertEqual('transfer', notify['States'][0]) self.assertEqual(acct1.get_address_base58(), notify['States'][1]) self.assertEqual(acct2.get_address_base58(), notify['States'][2]) self.assertEqual(amount, notify['States'][3]) notify = Event.get_notify_by_contract_address( event, sdk.native_vm.aio_ong().contract_address) self.assertEqual('transfer', notify['States'][0]) self.assertEqual(acct4.get_address_base58(), notify['States'][1]) self.assertEqual(self.gas_price * self.gas_limit, notify['States'][3])
async def test_withdraw_ong(self): amount, gas_price, gas_limit = 1, 500, 20000 tx_hash = await sdk.native_vm.aio_ong().withdraw( acct1, acct1.get_address(), amount, acct2, gas_price, gas_limit) self.assertEqual(64, len(tx_hash)) await asyncio.sleep(randint(14, 20)) event = await sdk.aio_rpc.get_contract_event_by_tx_hash(tx_hash) notify = Event.get_notify_by_contract_address( event, sdk.native_vm.aio_ong().contract_address) self.assertEqual('transfer', notify[0]['States'][0]) self.assertEqual(acct1.get_address_base58(), notify[0]['States'][2]) self.assertEqual(amount, notify[0]['States'][3]) notify = Event.get_notify_by_contract_address( event, sdk.native_vm.aio_ong().contract_address) self.assertEqual('transfer', notify[1]['States'][0]) self.assertEqual(acct2.get_address_base58(), notify[1]['States'][1]) self.assertEqual(gas_price * gas_limit, notify[1]['States'][3])
def test_transfer_from(self): b58_from_address = acct2.get_address_base58() b58_recv_address = acct1.get_address_base58() ont = sdk.native_vm.ont() amount = 1 tx_hash = ont.transfer_from(acct1, b58_from_address, b58_recv_address, amount, acct2, self.gas_price, self.gas_limit) self.assertEqual(64, len(tx_hash)) time.sleep(randint(10, 15)) event = sdk.default_network.get_contract_event_by_tx_hash(tx_hash) notify = Event.get_notify_by_contract_address(event, sdk.native_vm.ong().contract_address) self.assertEqual('transfer', notify['States'][0]) self.assertEqual(b58_from_address, notify['States'][1]) self.assertEqual(self.gas_price * self.gas_limit, notify['States'][3]) notify = Event.get_notify_by_contract_address(event, sdk.native_vm.ont().contract_address) self.assertEqual('transfer', notify['States'][0]) self.assertEqual(b58_from_address, notify['States'][1]) self.assertEqual(b58_recv_address, notify['States'][2]) self.assertEqual(amount, notify['States'][3])
def attack3(self): print('Eve: attack 3, g = p-1') # In this case, KB = ±1 depending on the parity of Kb. # If Kb is even, then KB = 1, s_A = 1 and we can # arbitrarily inject KA_B = ±1. # If Kb is odd, KB = -1, s_A = ±1 depending on the # parity of Ka, and we should inject KA_B = s_A. # Prop.: If g is a generator of Zₚ*, # Ka is even <=> KA (= g^Ka) is a square mod p # => trivial # <= KA = x², ∃n / x = gⁿ, KA = g²ⁿ = g^Ka, # hence Ka = 2n mod p-1, with p-1 even, # hence Ka is even # In that case, we can use Euler's criterion to test # whether KA is a square (and then choose KA_B = ±1). # https://en.wikipedia.org/wiki/Euler%27s_criterion # Problem: In practice, the given g = 2, probably for # optimized computation purposes, and is NOT a primitive # root. Even worse, its order might be odd, in which case # two Ka of different parity might generate the same KA # but different secrets when given KB = -1. # Solution: We pick KA_B at random, there is a 1/4 chance # to fail (Kb odd & bad choice), in which case we detect # if by a padding error and switch to a fully active # attack (as A and B do not share the same key). self.outB.put((self.p, self.p - 1)) # g_B := p-1 (= -1) ack = self.inB.get() assert ack == 'ACK' self.outA.put(ack) KA = self.inA.get() # primitive root deterministic case: #even_Ka = pow(KA, (p-1)//2, p)==1 # randomized case: even_Ka = randint(0, 1) == 0 self.outB.put(1 if even_Ka else self.p - 1) KB = self.inB.get() assert KB == 1 or KB == self.p - 1 self.outA.put(KB) self.s = 1 if KB == 1 or even_Ka else self.p - 1 self.key = SHA1.new(int_to_bytes(self.s)).digest()[:BS]
def test(tcount, bits=256): n = getPrime(int(bits/8)) #n = rsa.get_prime(bits / 8, 20) p = randint(1, n) p1 = (randint(1, n), randint(1, n)) q = curve_q(p1[0], p1[1], p, n) p2 = mulp(p, q, n, p1, randint(1, n)) c1 = [randint(1, n) for i in range(tcount)] c2 = [randint(1, n) for i in range(tcount)] c = list(zip(c1, c2)) t = time.time() for i, j in c: from_projective(addf(p, q, n, mulf(p, q, n, to_projective(p1), i), mulf(p, q, n, to_projective(p2), j)), n) t1 = time.time() - t t = time.time() for i, j in c: muladdp(p, q, n, p1, i, p2, j) t2 = time.time() - t return tcount, t1, t2
def runTest(self): """Cryptodome.Random.new()""" # Import the Random module and try to use it from Cryptodome import Random randobj = Random.new() x = randobj.read(16) y = randobj.read(16) self.assertNotEqual(x, y) z = Random.get_random_bytes(16) self.assertNotEqual(x, z) self.assertNotEqual(y, z) # Test the Random.random module, which # implements a subset of Python's random API # Not implemented: # seed(), getstate(), setstate(), jumpahead() # random(), uniform(), triangular(), betavariate() # expovariate(), gammavariate(), gauss(), # longnormvariate(), normalvariate(), # vonmisesvariate(), paretovariate() # weibullvariate() # WichmannHill(), whseed(), SystemRandom() from Cryptodome.Random import random x = random.getrandbits(16*8) y = random.getrandbits(16*8) self.assertNotEqual(x, y) # Test randrange if x>y: start = y stop = x else: start = x stop = y for step in range(1,10): x = random.randrange(start,stop,step) y = random.randrange(start,stop,step) self.assertNotEqual(x, y) self.assertEqual(start <= x < stop, True) self.assertEqual(start <= y < stop, True) self.assertEqual((x - start) % step, 0) self.assertEqual((y - start) % step, 0) for i in range(10): self.assertEqual(random.randrange(1,2), 1) self.assertRaises(ValueError, random.randrange, start, start) self.assertRaises(ValueError, random.randrange, stop, start, step) self.assertRaises(TypeError, random.randrange, start, stop, step, step) self.assertRaises(TypeError, random.randrange, start, stop, "1") self.assertRaises(TypeError, random.randrange, "1", stop, step) self.assertRaises(TypeError, random.randrange, 1, "2", step) self.assertRaises(ValueError, random.randrange, start, stop, 0) # Test randint x = random.randint(start,stop) y = random.randint(start,stop) self.assertNotEqual(x, y) self.assertEqual(start <= x <= stop, True) self.assertEqual(start <= y <= stop, True) for i in range(10): self.assertEqual(random.randint(1,1), 1) self.assertRaises(ValueError, random.randint, stop, start) self.assertRaises(TypeError, random.randint, start, stop, step) self.assertRaises(TypeError, random.randint, "1", stop) self.assertRaises(TypeError, random.randint, 1, "2") # Test choice seq = range(10000) x = random.choice(seq) y = random.choice(seq) self.assertNotEqual(x, y) self.assertEqual(x in seq, True) self.assertEqual(y in seq, True) for i in range(10): self.assertEqual(random.choice((1,2,3)) in (1,2,3), True) self.assertEqual(random.choice([1,2,3]) in [1,2,3], True) if sys.version_info[0] is 3: self.assertEqual(random.choice(bytearray(b('123'))) in bytearray(b('123')), True) self.assertEqual(1, random.choice([1])) self.assertRaises(IndexError, random.choice, []) self.assertRaises(TypeError, random.choice, 1) # Test shuffle. Lacks random parameter to specify function. # Make copies of seq seq = range(500) x = list(seq) y = list(seq) random.shuffle(x) random.shuffle(y) self.assertNotEqual(x, y) self.assertEqual(len(seq), len(x)) self.assertEqual(len(seq), len(y)) for i in range(len(seq)): self.assertEqual(x[i] in seq, True) self.assertEqual(y[i] in seq, True) self.assertEqual(seq[i] in x, True) self.assertEqual(seq[i] in y, True) z = [1] random.shuffle(z) self.assertEqual(z, [1]) if sys.version_info[0] == 3: z = bytearray(b('12')) random.shuffle(z) self.assertEqual(b('1') in z, True) self.assertRaises(TypeError, random.shuffle, b('12')) self.assertRaises(TypeError, random.shuffle, 1) self.assertRaises(TypeError, random.shuffle, "11") self.assertRaises(TypeError, random.shuffle, (1,2)) # 2to3 wraps a list() around it, alas - but I want to shoot # myself in the foot here! :D # if sys.version_info[0] == 3: # self.assertRaises(TypeError, random.shuffle, range(3)) # Test sample x = random.sample(seq, 20) y = random.sample(seq, 20) self.assertNotEqual(x, y) for i in range(20): self.assertEqual(x[i] in seq, True) self.assertEqual(y[i] in seq, True) z = random.sample([1], 1) self.assertEqual(z, [1]) z = random.sample((1,2,3), 1) self.assertEqual(z[0] in (1,2,3), True) z = random.sample("123", 1) self.assertEqual(z[0] in "123", True) z = random.sample(range(3), 1) self.assertEqual(z[0] in range(3), True) if sys.version_info[0] == 3: z = random.sample(b("123"), 1) self.assertEqual(z[0] in b("123"), True) z = random.sample(bytearray(b("123")), 1) self.assertEqual(z[0] in bytearray(b("123")), True) self.assertRaises(TypeError, random.sample, 1)
"""Return the y coordinate over curve (p, q, n) for given (x, sign)""" # optimized form of (x**3 - p*x - q) % n a = (((x * x) % n - p) * x - q) % n if __name__ == "__main__": from Cryptodome.Random.random import randint from Cryptodome.Util.number import getPrime import time t = time.time() n = getPrime(int(256/8)) #n = rsa.get_prime(256 / 8, 20) tp = time.time() - t p = randint(1, n) p1 = (randint(1, n), randint(1, n)) q = curve_q(p1[0], p1[1], p, n) r1 = randint(1, n) r2 = randint(1, n) q1 = mulp(p, q, n, p1, r1) q2 = mulp(p, q, n, p1, r2) s1 = mulp(p, q, n, q1, r2) s2 = mulp(p, q, n, q2, r1) # s1 == s2 tt = time.time() - t def test(tcount, bits=256): n = getPrime(int(bits/8)) #n = rsa.get_prime(bits / 8, 20) p = randint(1, n)