def _sha3_secp256k1_deploy_data(current_height,
bytecode,
value,
quota,
privatekey,
version,
receiver=None):
sender = get_sender(privatekey, False)
if privatekey is None:
temp = private_key()
privkey = PrivateKey(hex2bytes(temp))
else:
privkey = PrivateKey(hex2bytes(privatekey))
logger.debug(sender)
nonce = get_nonce()
logger.debug("nonce is {}".format(nonce))
tx = Transaction()
tx.valid_until_block = current_height + 88
tx.nonce = nonce
tx.version = version
if version == 0:
chainid = get_chainid()
logger.info("version-{}, chainid-{}".format(version, chainid))
tx.chain_id = chainid
elif version < 3:
chainid = get_chainid_v1()
logger.info("version-{}, chainid_v1-{}".format(version, chainid))
tx.chain_id_v1 = chainid.to_bytes(32, byteorder='big')
else:
logger.error("unexpected version {}".format(version))
if receiver is not None:
if version == 0:
tx.to = receiver
elif version < 3:
tx.to_v1 = hex2bytes(receiver)
else:
logger.error("unexpected version {}".format(version))
tx.data = hex2bytes(bytecode)
tx.value = value.to_bytes(32, byteorder='big')
tx.quota = quota
message = sha3(tx.SerializeToString())
logger.debug("hash message: {}")
sign_recover = privkey.ecdsa_sign_recoverable(message, raw=True)
sig = privkey.ecdsa_recoverable_serialize(sign_recover)
signature = binascii.hexlify(sig[0]) + binascii.hexlify(
bytes(bytearray([sig[1]])))
unverify_tx = UnverifiedTransaction()
unverify_tx.transaction.CopyFrom(tx)
unverify_tx.signature = hex2bytes(signature)
unverify_tx.crypto = Crypto.Value('DEFAULT')
logger.info("unverify_tx is {}".format(
binascii.hexlify(unverify_tx.SerializeToString())))
return binascii.hexlify(unverify_tx.SerializeToString())
def _blake2b_ed25519_deploy_data(current_height,
bytecode,
privatekey,
receiver=None):
sender = get_sender(private_key, True)
print(sender)
nonce = get_nonce(sender)
print("nonce is {}".format(nonce))
tx = Transaction()
tx.valid_until_block = current_height + 88
tx.nonce = nonce
if receiver is not None:
tx.to = receiver
tx.data = hex2bytes(bytecode)
message = _blake2b(tx.SerializeToString())
print("msg is {}".format(message))
sig = pysodium.crypto_sign_detached(message, hex2bytes(privatekey))
print("sig {}".format(binascii.b2a_hex(sig)))
pubkey = pysodium.crypto_sign_sk_to_pk(hex2bytes(privatekey))
print("pubkey is {}".format(binascii.b2a_hex(pubkey)))
signature = binascii.hexlify(sig[:]) + binascii.hexlify(pubkey[:])
print("signature is {}".format(signature))
unverify_tx = UnverifiedTransaction()
unverify_tx.transaction.CopyFrom(tx)
unverify_tx.signature = hex2bytes(signature)
unverify_tx.crypto = Crypto.Value('SECP')
print("unverify_tx is {}".format(
binascii.hexlify(unverify_tx.SerializeToString())))
return binascii.hexlify(unverify_tx.SerializeToString())
def generate_deploy_data(bytecode, privatekey, receiver=None):
privkey = PrivateKey(hex2bytes(privatekey))
sender = get_sender()
print(sender)
nonce = get_nonce(sender)
print("nonce is {}".format(nonce))
tx = Transaction()
tx.valid_until_block = 4294967296
tx.nonce = nonce
if receiver is not None:
tx.to = receiver
tx.data = hex2bytes(bytecode)
message = sha3(tx.SerializeToString())
sign_recover = privkey.ecdsa_sign_recoverable(message, raw=True)
sig = privkey.ecdsa_recoverable_serialize(sign_recover)
signature = binascii.hexlify(
sig[0]) + binascii.hexlify(bytes(bytearray([sig[1]])))
unverify_tx = UnverifiedTransaction()
unverify_tx.transaction.CopyFrom(tx)
unverify_tx.signature = hex2bytes(signature)
unverify_tx.crypto = Crypto.Value('SECP')
signed_transaction = SignedTransaction()
signed_transaction.transaction_with_sig.CopyFrom(unverify_tx)
signed_transaction.tx_hash = sha3(unverify_tx.SerializeToString())
pub = recover_pub(hex2bytes(privatekey))
signed_transaction.signer = pub
#print(binascii.hexlify(pub))
return binascii.hexlify(signed_transaction.SerializeToString())
def _blake2b_ed25519_deploy_data(current_height,
bytecode,
value,
quota,
privatekey,
version,
receiver=None):
sender = get_sender(private_key, True)
logger.debug(sender)
nonce = get_nonce()
logger.debug("nonce is {}".format(nonce))
tx = Transaction()
tx.valid_until_block = current_height + 88
tx.nonce = nonce
tx.version = version
if version == 0:
chainid = get_chainid()
logger.info("version is {}".format(version))
logger.info("chainid is {}".format(chainid))
tx.chain_id = chainid
elif version < 3:
chainid = get_chainid_v1()
logger.info("version is {}".format(version))
logger.info("chainid_v1 is {}".format(chainid))
tx.chain_id_v1 = chainid.to_bytes(32, byteorder='big')
else:
logger.error("unexpected version {}".format(version))
if receiver is not None:
if version == 0:
tx.to = receiver
elif version < 3:
tx.to_v1 = hex2bytes(receiver)
else:
logger.error("unexpected version {}".format(version))
tx.data = hex2bytes(bytecode)
tx.value = value.to_bytes(32, byteorder='big')
tx.quota = quota
message = _blake2b(tx.SerializeToString())
logger.debug("blake2b msg")
sig = pysodium.crypto_sign_detached(message, hex2bytes(privatekey))
logger.debug("sig {}".format(binascii.b2a_hex(sig)))
pubkey = pysodium.crypto_sign_sk_to_pk(hex2bytes(privatekey))
logger.debug("pubkey is {}".format(binascii.b2a_hex(pubkey)))
signature = binascii.hexlify(sig[:]) + binascii.hexlify(pubkey[:])
logger.debug("signature is {}".format(signature))
unverify_tx = UnverifiedTransaction()
unverify_tx.transaction.CopyFrom(tx)
unverify_tx.signature = hex2bytes(signature)
unverify_tx.crypto = Crypto.Value('DEFAULT')
logger.info("unverify_tx is {}".format(
binascii.hexlify(unverify_tx.SerializeToString())))
return binascii.hexlify(unverify_tx.SerializeToString())
def create_screen(sc_line, modes, edid_data, connected):
name = sc_line.split(' ')[0]
model = ""
manufacturer_id = ""
manufacturer = ""
product_id = 0
serial_no = 0
physical_width = 30.0
physical_height = 30.0
if(len(edid_data) > 0):
bytes = hex2bytes("".join(edid_data[0:8]))
parsed_edid = Edid(bytes)
model = parsed_edid.name if parsed_edid.name else ""
manufacturer_id = parsed_edid.manufacturer_id
manufacturer = parsed_edid.manufacturer
physical_width = parsed_edid.width
physical_height = parsed_edid.height
product_id = parsed_edid.product
serial_no = parsed_edid.serial_no
# Set dpi of modes
for mode in modes:
mode.dpi = mode.height / (physical_height/2.54)
# if connected
rot = None
if modes:
fr = sc_line.split(' ')
if len(fr) > 2:
rot = str_to_rot(sc_line.split(' ')[3])
return Screen(name, 'primary' in sc_line, rot, modes, manufacturer_id, manufacturer, model, physical_width, physical_height, product_id, serial_no, connected)
def c5():
plain_text = b"""Burning 'em, if you ain't quick and nimble
I go crazy when I hear a cymbal"""
key = b"ICE"
cipher_text = encrypt_xor(key, plain_text)
expected_hex = """0b3637272a2b2e63622c2e69692a23693a2a3c6324202d623d63343c2a26226324272765272
a282b2f20430a652e2c652a3124333a653e2b2027630c692b20283165286326302e27282f"""
expected = hex2bytes(expected_hex)
print("S1C5 - cipher_text is [{}]: correct {}".format(
cipher_text.hex(), expected == cipher_text))
def _sha3_secp256k1_deploy_data(current_height,
bytecode,
privatekey,
receiver=None):
sender = get_sender(privatekey, False)
if privatekey is None:
temp = private_key()
privkey = PrivateKey(hex2bytes(temp))
else:
privkey = PrivateKey(hex2bytes(privatekey))
print(sender)
nonce = get_nonce(sender)
print("nonce is {}".format(nonce))
tx = Transaction()
tx.valid_until_block = current_height + 88
tx.nonce = nonce
tx.quota = 9999999
if receiver is not None:
tx.to = receiver
tx.data = hex2bytes(bytecode)
message = sha3(tx.SerializeToString())
print("message: {}".format(message))
sign_recover = privkey.ecdsa_sign_recoverable(message, raw=True)
sig = privkey.ecdsa_recoverable_serialize(sign_recover)
signature = binascii.hexlify(sig[0]) + binascii.hexlify(
bytes(bytearray([sig[1]])))
unverify_tx = UnverifiedTransaction()
unverify_tx.transaction.CopyFrom(tx)
unverify_tx.signature = hex2bytes(signature)
unverify_tx.crypto = Crypto.Value('SECP')
print("unverify_tx is {}".format(
binascii.hexlify(unverify_tx.SerializeToString())))
return binascii.hexlify(unverify_tx.SerializeToString())
def get_edids():
output = subprocess.check_output(["xrandr", "--verbose"])
edids = []
lines = output.splitlines()
for i, line in enumerate(lines):
line = line.decode().strip()
if line.startswith("EDID:"):
selection = lines[i+1:i+9]
selection = list(s.decode().strip() for s in selection)
selection = "".join(selection)
bytes = util.hex2bytes(selection)
edids.append(bytes)
return edids
def get_edids():
output = subprocess.check_output(["xrandr", "--verbose"])
edids = []
lines = output.splitlines()
for i, line in enumerate(lines):
line = line.decode().strip()
if line.startswith("EDID:"):
selection = lines[i + 1:i + 9]
selection = list(s.decode().strip() for s in selection)
selection = "".join(selection)
bytes = util.hex2bytes(selection)
edids.append(bytes)
return edids
def _generate_old(privkey=None):
keccak = sha3.keccak_256()
if privkey is None:
priv = SigningKey.generate(curve=SECP256k1)
else:
priv = SigningKey.from_string(hex2bytes(privkey), curve=SECP256k1)
pub = priv.get_verifying_key().to_string()
keccak.update(pub)
address = keccak.hexdigest()[24:]
save_privkey(binascii.hexlify(priv.to_string()))
save_pubkey(binascii.hexlify(pub))
save_address(address)
def test():
b = util.hex2bytes('41 42 43')
util.write_file('C:/tmp/a.txt', b)
