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)
