def test_decrypt(self):
# generate an ECIES key pair
skey = ecies.gen_private_key()
pkey = ecies.gen_public_key(skey)
tag = random_scalar()
# test decryption
self.assertEqual(
ecies.decrypt(skey, tag, ecies.encrypt(pkey, tag, '')), '')
self.assertEqual(
ecies.decrypt(skey, tag, ecies.encrypt(pkey, tag, 'message')),
'message')
self.assertEqual(
ecies.decrypt(
skey, tag,
ecies.encrypt(pkey, tag,
'Four score and seven long messages ago')),
'Four score and seven long messages ago')
self.assertEqual(
ecies.decrypt(skey, tag, ecies.encrypt(pkey, tag, str(G))), str(G))
# test bad types
with self.assertRaises(TypeError):
ecies.decrypt(None, tag, ecies.encrypt(None, tag, ''))
with self.assertRaises(TypeError):
ecies.decrypt(skey, tag, None)
def icies_test(self, sk_hex, pk_hex, data):
# assymtetric encryption/decryption test
print(decrypt(sk_hex, encrypt(pk_hex, data)))
secp_k = generate_key()
sk_bytes = secp_k.secret # bytes
pk_bytes = secp_k.public_key.format(True) # bytes
print(decrypt(sk_bytes, encrypt(pk_bytes, data)))
def gen_account(public_key,a):
r = dumb25519.random_scalar()
co = G*a + H*r
ek = dumb25519.random_scalar()
s = dumb25519.hash_to_scalar(str(public_key.tpk)+str(public_key.spk)+str(public_key.X)+str(ek))
pk = public_key.X + H*s
_ek = ecies.encrypt(public_key.tpk,str(pk)+str(co),str(ek))
_a = ecies.encrypt(public_key.spk,str(pk)+str(co),str(a))
_r = ecies.encrypt(public_key.spk,str(pk)+str(co),str(r))
return Account(pk,co,_ek,_a,_r),DepositKey(a,r)
def ecciespy_encrypt(text):
eth_k = generate_eth_key()
prvhex = eth_k.to_hex()
pubhex = eth_k.public_key.to_hex()
data = bytes(text,'utf-8')
decrypt(prvhex, encrypt(pubhex, data))
return True
def ies(ptxt):
sk = generate_key()
sk_bytes = sk.secret
pk_bytes = sk.public_key.format(True)
ctxt = encrypt(pk_bytes, ptxt.encode())
print("Ctxt:", ctxt)
return decrypt(sk_bytes, ctxt)
def test_elliptic(self):
data = self.test_string
k = generate_eth_key()
prvhex = k.to_hex()
pubhex = k.public_key.to_hex()
self.assertEqual(data, decrypt(prvhex, encrypt(pubhex, data)))
k = generate_key()
prvhex = k.to_hex()
pubhex = k.public_key.format(False).hex()
self.assertEqual(data, decrypt(prvhex, encrypt(pubhex, data)))
k = generate_key()
prvhex = k.to_hex()
pubhex = k.public_key.format(True).hex()
self.assertEqual(data, decrypt(prvhex, encrypt(pubhex, data)))
async def handle_request(reader, writer):
data = await reader.read(1024)
addr = writer.get_extra_info('peername')
print(f"Received task from {addr!r}")
msg = json.loads(data.decode())
print(msg)
send_msg = {'status': 'no'}
productId = msg['productId']
public = msg['public']
sql = "SELECT * FROM apps_key_db_one WHERE productId = %s" % (
int(productId))
cursor.execute(sql)
data = cursor.fetchone()
encrypt_key = b2a_hex(
encrypt(
public,
decrypt(keyring.get_password("DRMDEMO", "keyManagerOnePrivate"),
a2b_hex(data[2])))).decode()
# print(encrypt_key)
send_msg['status'] = 'ok'
send_msg['key'] = encrypt_key
send_data = json.dumps(send_msg)
writer.write(send_data.encode())
await writer.drain()
print(f"finsh {addr!r} work")
writer.close()
def keygen():
dk_string1 = getpass.getpass(prompt="Decryption Key 1: ")
if len(dk_string1) < 6:
raise ValueError(
"For your own security each passphrase should be at least 6 characters"
)
sk_int1 = int(hashlib.sha256(dk_string1.encode()).hexdigest(), 16)
dk_string2 = getpass.getpass(prompt="Decryption Key 2: ")
if len(dk_string2) < 6:
raise ValueError(
"For your own security each passphrase should be at least 6 characters"
)
sk_int2 = int(hashlib.sha256(dk_string2.encode()).hexdigest(), 16)
sk_int = (sk_int1 * sk_int2) % curves.SECP256k1.order
sk = keys.SigningKey.from_secret_exponent(sk_int,
curve=curves.SECP256k1,
hashfunc=hashlib.sha256)
pk = sk.verifying_key.pubkey
pub = "04" + hex(pk.point.x())[2:] + hex(pk.point.y())[2:]
try:
c = encrypt(pub, b'abc')
except:
raise ValueError(
"Sorry: this passphrase combination does not work. Try again and change one passphrase!"
)
print("Encryption Key:", pub)
def encrypt_key(self, pub_key, key_str):
try:
pub_point = pub_key.point()
pub = coincurve.PublicKey.from_point(x=pub_point.x(),
y=pub_point.y())
return base64.urlsafe_b64encode(encrypt(pub.format(), key_str))
except:
return ''
def AsymEncrypt(public_key_str, plaintext):
try:
public_point = PublicKey(public_key_str).point()
public_key = coincurve.PublicKey.from_point(x=public_point.x(),
y=public_point.y())
return encrypt(public_key.format(True), plaintext)
except:
return b""
def test_encryption_decryption():
eth_k = generate_eth_key()
private_key_hex = eth_k.to_hex() # hex string
public_key_hex = eth_k.public_key.to_hex() # hex string
data = 'hi there'
result = decrypt(private_key_hex, encrypt(public_key_hex, data.encode()))
print(result)
print('decoded=' + result.decode())
assert result == data.encode()
assert data == result.decode()
def attmpt4_alg(pub_key, data):
i_pk = int(pub_key, 16)
num_bytes = i_pk.bit_length() // 8 + 1
# Only works with big endian despite sys.byteorder returning 'little'
# Maybe something to do with how bitcoin does it.
endianness = 'big'
b_pk = i_pk.to_bytes(num_bytes, endianness)
encrypted = ecies.encrypt(b_pk, data)
return encrypted
def atmpt2():
''' solution that works...'''
from bit import Key
wif_private_key = 'cPhnVqon8qro8WmFJ5ma24Lrp59XnudnhywdkPcERw4xM9Mhbr1e'
private_key = Key(wif_private_key)
encrypted = ecies.encrypt(private_key.public_key, b'this is a test')
decrypted = ecies.decrypt(private_key._pk.secret, encrypted)
print('encrypted', encrypted)
print('decrypted', decrypted)
def encrypt_user_data(json_data, priv_key=None, pub_key=None):
if priv_key is None and pub_key is None:
raise Exception(
"Only one of {priv_key, pub_key} may retain a value of None")
data = encode_and_format(json_data)
if pub_key is not None:
i_pk = int(pub_key, 16)
num_bytes = i_pk.bit_length() // 8 + 1
# Only works with big endian despite sys.byteorder returning 'little'
# Maybe something to do with how bitcoin does it.
endianness = 'big'
b_pk = i_pk.to_bytes(num_bytes, endianness)
encrypted = ecies.encrypt(b_pk, data)
else:
key = Key(priv_key)
encrypted = ecies.encrypt(key.public_key, data)
return encrypted
def cipher_message(self, message):
_logger.info("Usuario %s: Está cifrando un mensaje." % self._name)
friend = message.split(":")[0]
if friend in self._keys_holder:
_logger.info("Usuario %s: Llave pública de %s en el llavero personal." % (self._name, friend))
cypher_messagge = encrypt(self._keys_holder.get(friend), message.split(":")[1].encode())
_logger.info("Usuario %s: Mensaje cifrado: %s" % (self._name, cypher_messagge))
return cypher_messagge
else:
_logger.error("Usuario %s: Llave pública de %s no está en el llavero personal." % (self._name, friend))
return False
def _calc_invitation(pk, addr, note):
if len(note) > MAX_NOTE_LEN:
raise Exception("note too long")
note_bytes = bytes(note, 'utf-8')
extended_note_bytes = note_bytes
if len(note_bytes) != MAX_NOTE_LEN:
extended_note_bytes += urandom(MAX_NOTE_LEN - len(note_bytes))
raw_invitation = ZkTransfer._pad_hexstr(addr) + Web3.toBytes(
len(note_bytes)) + extended_note_bytes
invitation = encrypt(pk, raw_invitation)
return invitation
def run_test(client, base_ddo_url, events_instance, flags=None, encryption_key=None):
web3 = get_web3()
block = web3.eth.blockNumber
_ddo = new_ddo(test_account1, web3, f'dt.{block}')
did = _ddo.id
ddo_string = json.dumps(dict(_ddo))
data = Web3.toBytes(text=ddo_string)
_flags = flags or 0
if flags is not None:
data = lzma.compress(data)
# mark bit 1
_flags = _flags | 1
if encryption_key is not None:
# ecies encrypt - bit 2
_flags = _flags | 2
key = eth_keys.KeyAPI.PrivateKey(encryption_key)
data = ecies.encrypt(key.public_key.to_hex(), data)
send_create_update_tx('create', did, bytes([_flags]), data, test_account1)
get_event(EVENT_METADATA_CREATED, block, did)
events_instance.process_current_blocks()
published_ddo = get_ddo(client, base_ddo_url, did)
assert published_ddo['id'] == did
_ddo['service'][0]['attributes']['main']['name'] = 'Updated ddo by event'
ddo_string = json.dumps(dict(_ddo))
data = Web3.toBytes(text=ddo_string)
if flags is not None:
data = lzma.compress(data)
if encryption_key is not None:
key = eth_keys.KeyAPI.PrivateKey(encryption_key)
data = ecies.encrypt(key.public_key.to_hex(), data)
send_create_update_tx('update', did, bytes([_flags]), data, test_account1)
get_event(EVENT_METADATA_UPDATED, block, did)
events_instance.process_current_blocks()
published_ddo = get_ddo(client, base_ddo_url, did)
assert published_ddo['id'] == did
assert published_ddo['service'][0]['attributes']['main']['name'] == 'Updated ddo by event'
def index():
prv = request.form.get("prv", "")
pub = request.form.get("pub", "")
data = request.form.get("data", "")
if prv and data:
decrypted = decrypt(prv, bytes.fromhex(data))
return decrypted
elif pub and data:
encrypted = encrypt(pub, data.encode())
return encrypted.hex()
else:
abort(400)
def pub_encrypt(text, public_key):
"""
text: bytes
returns bytes type object
"""
try:
if isinstance(text, str):
text = text.encode()
return encrypt(public_key, text)
except Exception as e:
logging.error(f"While encrypting data with publickey{public_key} and data {text}is {e}")
raise Exception("Couldnt encrypt with public key")
def encrypt_url():
raw_text = str(url_display.get('1.0', tk.END))
raw_text = bytes(raw_text, 'utf-8')
privKey = generate_eth_key()
privKeyHex = privKey.to_hex()
pubKeyHex = privKey.public_key.to_hex()
encrypted = encrypt(pubKeyHex, raw_text)
encrypted = binascii.hexlify(encrypted)
result = '\n\nEncrypted text:\n{}'.format(encrypted)
tab5_display_text.insert(tk.END, result)
result1 = '\n{} '.format(privKeyHex)
tab5_display1.insert(tk.END, result1)
def test_elliptic(self):
data = self.test_string
k = generate_eth_key()
sk_hex = k.to_hex()
pk_hex = k.public_key.to_hex()
self.assertEqual(data, decrypt(sk_hex, encrypt(pk_hex, data)))
k = generate_key()
sk_hex = k.to_hex()
pk_hex = k.public_key.format(False).hex()
self.assertEqual(data, decrypt(sk_hex, encrypt(pk_hex, data)))
self.assertEqual(
data,
decrypt(bytes.fromhex(sk_hex), encrypt(bytes.fromhex(pk_hex),
data)))
k = generate_key()
sk_hex = k.to_hex()
pk_hex = k.public_key.format(True).hex()
self.assertEqual(data, decrypt(sk_hex, encrypt(pk_hex, data)))
self.assertEqual(
data,
decrypt(bytes.fromhex(sk_hex), encrypt(bytes.fromhex(pk_hex),
data)))
self.assertRaises(TypeError, encrypt, 1, data)
self.assertRaises(TypeError, decrypt, 1,
encrypt(bytes.fromhex(pk_hex), data))
def encrypt_text():
raw_text = str(entry.get('1.0', tk.END)) #Get input
raw_text = bytes(raw_text, 'utf-8')
privKey = generate_eth_key() #Generate Private Key
privKeyHex = privKey.to_hex() #Convert it to Hexadecimal
pubKeyHex = privKey.public_key.to_hex() #Make Public Key
encrypted = encrypt(pubKeyHex, raw_text)
encrypted = binascii.hexlify(encrypted)
result = '\n\nEncrypted text:\n{}'.format(encrypted) #Print Result
tab3_display.insert(tk.END, result)
result1 = '\n{}'.format(privKeyHex)
#result1 = '\nPrivate Key: {}\nPublic Key: {}'.format(privKeyHex,pubKeyHex)
tab3_display1.insert(tk.END, result1)
def test_encrypt_and_descrypt_signature():
# Rsk Address 0x67a03d727b61a4ffd3721f79d52a3baea1b63ea0
pubkey = 'e00f009e7d4308ac39216bbe964d7ac933ac4dfce8b0c369848f4fcae4664fca2dab' \
'9a0e3e9db5eef5fb3de25f78dd0161f707a0075a179b1419d72121aa0c80'
privkey = '3f5d3cda6320fd57f4d47e50c3404e7e43cfb60968d7ef13eb6873760b445e47'
# This is a result after sign the following data transport02.raiden.network, with this privkey and encode_hex
signed_data = b'0x30f852f75ea11df467e8a518e3e7ceec9e106f4c2c50027e3277e239af06a' \
b'f0730fef7b16f32943b62b03fe0e479a555d5bf7686318327b9c15f514a99da07f11c'
encrypt_data = encrypt(pubkey, signed_data)
descrypt_data = decrypt(privkey, encrypt_data)
assert signed_data == descrypt_data
def encrypt(cls, plain: AnyStr, pub_key) -> bytes:
"""
Encrypt with receiver's public key
:param plain: data to encrypt
:param pub_key: public key
:return: encrypted data
"""
if type(plain) == str:
plain = plain.encode("utf8")
if type(plain) != bytes:
raise TypeError("message only support str or bytes.")
cipher = ecies.encrypt(pub_key, plain)
return cipher
def encrypt(self, message, public_key=None):
"""
Return message encrypted with public key
@param message bytes
@param public_key bytes
"""
if isinstance(message, str):
message = message.encode()
if public_key is None:
public_key = self.public_key
else:
public_key = KeyAPI.PublicKey(public_key)
return ecies.encrypt(message, public_key)
def attmpt_paicoin():
pub_key_addr = 'MnqtQVYSkEinTukeaz2zQdJbo4fivzJMip'
pub_key = '02b01692bb20206f03417f9cfd3dfc51e545feb1d7ff5f5f6648a9747988009e8a'
pub_key = '031a5808d3d801fb08e43209566803e950e2bad98b1bec39ac0f736799b1b1533a'
priv_key = 'aZiUxsYszMG6REqQ8kLiaTU9TNLoyMwPuX7q24YmbF5AA7kDw784'
i_pk = int(pub_key, 16)
num_bytes = i_pk.bit_length() // 8 + 1
# Only works with big endian despite sys.byteorder returning 'little'
# Maybe something to do with how bitcoin does it.
endianness = 'big'
b_pk = i_pk.to_bytes(num_bytes, endianness)
encrypted = ecies.encrypt(
b_pk, b'We have had success with the an even public key')
decrypted = ecies.decrypt(sk._pk.secret, encrypted)
def encrypt_w_pubkey(data, public_key):
##this encrypts the mnemonic witht he public key
##Mnemonic must be in bytes
if isinstance(data, str):
data = data.encode()
try:
encrypted_data = encrypt(public_key, data)
except Exception as e:
logger.error(
f"While encrypting data with publickey{public_key} and data {data} is {e}"
)
raise Exception("Couldnt encrypt with public key")
##hex encoding aes key
return encrypted_data
def generate(request):
private_key = utils.sha3(os.urandom(4096))
raw_address = utils.privtoaddr(private_key)
addressif = address.to_normalized_address(raw_address)
keyether = utils.encode_hex(private_key)
sk = SigningKey.from_string(bytes.fromhex(keyether), curve=SECP256k1)
public_key = sk.get_verifying_key() #public_key
pkey = public_key.to_string().hex().strip()
data = b'https://darchnetwork.com/'
encryptedval = encrypt(pkey, data)
print("encryptedval", utils.encode_hex(encryptedval))
decryptedvalue = decrypt(keyether, encryptedval)
print("decrypted value is here", decryptedvalue)
#public_key = public_key.to_string().hex()
return render(request, "homomorphic/skeleton.html", locals())
def sendMediaLink(userId, destId, mediaId, address):
sort_contract = init_contract(address)
isCreator = sort_contract.functions.isCreator(userId).call()
if not isCreator:
return "Function Not available for you\n"
mediaBuyer = sort_contract.functions.getMediaBuyer(mediaId).call()
if destId not in mediaBuyer:
return "Media not bought by the user\n"
mediaAlreadyHave = sort_contract.functions.getMediaAlreadyHave(
mediaId).call()
if destId in mediaAlreadyHave:
return "Media Link already sent to the user\n"
sender_user = getUserByID(userId, address)
receiver_user = getUserByID(destId, address)
sender_address = sender_user[3]
receiver_address = receiver_user[3]
receiver_pubkey = receiver_user[4]
mediaURL = str(random.randrange(1, 100000))
mediaURL_encrypted = encrypt(receiver_pubkey, mediaURL.encode())
mediaURL_encrypted = "".join(
["{:02X}".format(c) for c in mediaURL_encrypted])
# w3.eth.sendTransaction({'to':w3.toChecksumAddress(receiver), 'from':w3.toChecksumAddress(sender), 'value':w3.toWei(0, "ether"), 'data':w3.toHex(mediaURL.encode())})
tx_hash = sort_contract.functions.sendMediaLink(
userId, destId, mediaId, str(mediaURL_encrypted)).transact({
'txType':
"0x1",
'from':
w3.eth.accounts[0],
'gas':
2409638
})
receipt1 = w3.eth.getTransactionReceipt(tx_hash)
while ((receipt1 is None)):
time.sleep(1)
receipt1 = w3.eth.getTransactionReceipt(tx_hash)
if receipt1 is not None:
print("media:{0}".format(receipt1['gasUsed']))
print("Link Sent")
return "Done"
def _encrypt_nonce(self, pub_key, nonce, key_type):
'''
method responsible for generating the encrypted nonce
:param pub_key: the public key used to encrypt the nonce
:param nonce: the nonce to be encrypted
:param key_type: the type of key being used for the encryption
:return: the nonce encrypted with the public key
'''
if key_type.upper() == global_variables.SECP256k1_TYPE:
#key = ecies.utils.generate_eth_key()
#priv_key = key.to_hex()
#pub_key = key.public_key.to_hex()
encrypted_nonce = ecies.encrypt(str(pub_key), bytes(nonce, 'utf-8'))
return encrypted_nonce
else:
# not in supported key types
raise ValueError('invalid key type specified')
