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()