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 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 generate():
keydict = {}
privKey = generate_eth_key()
keydict["private"] = privKey.to_hex()
keydict["public"] = privKey.public_key.to_hex()
return keydict
def ecies_key_generation():
private_key = ec.generate_private_key(ec.SECP384R1())
public_key = private_key.public_key()
priv_key = generate_eth_key()
priv_key_hex = priv_key.to_hex()
pub_key_hex = priv_key.public_key.to_hex()
return priv_key_hex, pub_key_hex
def generateKeysECC():
"""This function generates keys needed for ECC
Input:
bitLength: key bit length
Outputs:
private, public keys of ECC
"""
key = generate_eth_key()
return key.to_hex(), key.public_key.to_hex()
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 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 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 init():
if os.path.exists('key'):
try:
with open('key', 'rb') as f:
eth_k = PrivateKey(f.read())
return eth_k
except Exception as e:
print('55', e)
pass
eth_k = generate_eth_key()
with open('key', 'wb') as f:
f.write(eth_k.to_bytes())
return eth_k
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)))
def _generate_random_pubkey():
ethkey = generate_eth_key()
return ethkey.public_key.to_hex()
def ecc_generate() -> tuple:
eth_k = generate_eth_key()
sk_hex = eth_k.to_hex()
pk_hex = eth_k.public_key.to_hex()
return pk_hex, sk_hex
def main():
parser = argparse.ArgumentParser(description=__description__)
parser.add_argument(
"-e",
"--encrypt",
action="store_true",
help="encrypt with public key, exclusive with -d",
)
parser.add_argument(
"-d",
"--decrypt",
action="store_true",
help="decrypt with private key, exclusive with -e",
)
parser.add_argument("-g",
"--generate",
action="store_true",
help="generate ethereum key pair")
parser.add_argument("-k",
"--key",
type=argparse.FileType("r"),
help="public or private key file")
parser.add_argument(
"-D",
"--data",
nargs="?",
type=argparse.FileType("rb"),
default=sys.stdin,
help=
"file to encrypt or decrypt, if not specified, it will read from stdin",
)
parser.add_argument(
"-O",
"--out",
nargs="?",
type=argparse.FileType("wb"),
default=sys.stdout,
help=
"encrypted or decrypted file, if not specified, it will write to stdout",
)
args = parser.parse_args()
if args.generate:
k = generate_eth_key()
prv, pub, addr = (
k.to_hex(),
k.public_key.to_hex(),
k.public_key.to_checksum_address(),
)
print("Private: {}\nPublic: {}\nAddress: {}".format(prv, pub, addr))
return
if args.encrypt == args.decrypt:
parser.print_help()
return
if not args.key:
parser.print_help()
return
key = args.key.read().strip()
if args.encrypt:
plaintext = args.data.read()
if isinstance(plaintext, str):
plaintext = plaintext.encode()
data = encrypt(key, plaintext)
if args.out == sys.stdout:
data = data.hex()
else:
ciphertext = args.data.read()
if isinstance(ciphertext, str):
# if not bytes, suppose hex string
ciphertext = bytes.fromhex(ciphertext.strip())
data = decrypt(key, ciphertext)
if args.out == sys.stdout:
# if binary data, print hex; if not, print utf8
data = readablize(data)
args.out.write(data)
def generate_encryption_keys():
k = generate_eth_key()
prvhex = k.to_hex()
pubhex = k.public_key.to_hex()
return CryptoKeypair(prvhex, pubhex)
def main():
# in case a file is not input in the command line
if (len(sys.argv) < 2):
print("invalid use of program")
print("Please add one file path as an argument for this program")
exit()
else:
# generate secret key to be used for public, private key creation
# this would be the shared secret value between the users
k = generate_eth_key()
# making and saving the private key
prvhex = k.to_hex()
print("private key", prvhex)
# making and saving the public key
pubhex = k.public_key.to_hex()
print("public key", pubhex)
# open file with the message that is being encrypted and save the message to a variable
file = open(sys.argv[1], 'r')
# begin encryption
print("encrypting...")
# read the file to a variable for use in the encryption function
try:
message = file.read()
except:
# catching invalid inputs so it doesn't crash
print("invalid path or file")
exit()
# convert the message into bytes to be used in the function
byte_message = str.encode(message)
# save the encrypted message so that it may be sent
secret = encrypt(pubhex, byte_message)
#finished with encryption
print("encrypted")
# print the encrypted message
print(secret)
# begin decryption of the message
print("decrypting...")
# saving decrypted message in case it should be written to a file or used elsewhere
cracked = decrypt(prvhex, secret)
# finished decryption
print("decrypted")
#printing the final message after decryption
print(cracked)
# closing the file that was encrypted/decrypted
file.close()
# antes de executar o código abaixo, é necessário importar
# o pacote eciespy no python. para isso, basta executar o
# comando abaixo.
#
# pip install eciespy
from ecies.utils import generate_eth_key
from ecies import encrypt, decrypt
import binascii
privKey = generate_eth_key()
privKeyHex = privKey.to_hex()
pubKeyHex = privKey.public_key.to_hex()
print("Encryption public key:", pubKeyHex)
print("Decryption private key:", privKeyHex)
plaintext = b'Some plaintext for encryption'
print("Plaintext:", plaintext)
encrypted = encrypt(pubKeyHex, plaintext)
print("Encrypted:", binascii.hexlify(encrypted))
decrypted = decrypt(privKeyHex, encrypted)
print("Decrypted:", decrypted)
def __init__(self, username):
self.username_hash = sha512(bytes(username, "utf-8")).hexdigest()
eth_k = generate_eth_key()
self.private_key = eth_k.to_hex()
self.public_key = eth_k.public_key.to_hex()
del eth_k
def generateEciesKey(self):
eth_key = generate_eth_key()
return eth_key
from web3 import Web3, HTTPProvider, IPCProvider, WebsocketProvider
import solcx
import json
from typing import List
# web3 = Web3(Web3.HTTPProvider('http://localhost:7545'))
# account2 = web3.eth.accounts[2]
# contract_address = "0xd558ae5fad9E835048Bb62e9545a830553B9C1bA"
from ecies.utils import generate_eth_key, generate_key
from ecies import encrypt, decrypt
eth_k = generate_eth_key()
print(eth_k)
sk_hex = eth_k.to_hex() # hex string
print(sk_hex)
pk_hex = eth_k.public_key.to_hex() # hex string
print(pk_hex)
data = b'this is a test'
encrypt(pk_hex, data)
# print(decrypt(sk_hex, encrypt(pk_hex, data)))
# b'this is a test'
secp_k = generate_key()
sk_bytes = secp_k.secret # bytes
pk_bytes = secp_k.public_key.format(True) # bytes
# decrypt(sk_bytes, encrypt(pk_bytes, data))
# b'this is a test'
'''
客户端功能
用户：发送方、接收方
5个步骤：存款、打开通道、转账、关闭通道、取款
存款：创建票据，用户界面接口Deposit(public_key, transfer_value)
def __init__(self, name):
self._name = name
self._keys_holder = {}
self.__private_key = generate_eth_key()
self.__public_key = self._generate_public_key()
