def __init__(self, wallets): self.__private_key, self.public_key = generate_keys() self.blockchain = Blockchain() self.wallets = wallets self.transactions_cache = [] self.last_transaction = None self.genesis()
def get(self): """ Return top 100 words :return: """ try: # Check if public key is generated publickey_file = open("pub.pem", "rb") except FileNotFoundError: # lets generate public and private key files privatekey, publickey = generate_keys() export_private_key(privatekey) export_public_key(publickey) else: publickey_file.close() words = [] try: words = yield get_top_words(limit=True) except err.ProgrammingError: # In case of ProgrammingError we need to create words & urls tables sql = "CREATE TABLE IF NOT EXISTS words (WordHash VARCHAR(100) NOT NULL ," " \ " "Word VARCHAR(255) NOT NULL," " \ " "TotalFrequency INT NOT NULL," " \ " "PRIMARY KEY (WordHash)" " \ " ");" yield safe_create_table('words', sql) sql = "CREATE TABLE IF NOT EXISTS urls (UrlHash VARCHAR(100) NOT NULL ," " \ " "Url VARCHAR(100) NOT NULL," " \ " "Sentiment VARCHAR(10) NOT NULL," " \ " "PRIMARY KEY (UrlHash, Url)" " \ " ");" yield safe_create_table('urls', sql) self.render("templates/home.html", words=words)
from node import Node from node import new_sender from node import new_listener from constants import ADDRESS_MC from constants import ADDRESS_CM import utils as utils utils.generate_keys(False) core = Node() core.add_listener(new_listener(ADDRESS_CM), ADDRESS_CM) core.accept_connection(ADDRESS_CM) encrypted_symmetric_key = core.receive_message(ADDRESS_CM) ciphertext = core.receive_message(ADDRESS_CM) core.close_connection(ADDRESS_CM) symmetric_session_key = utils.decrypt_rsa('keys/merchant_private_key.pem', encrypted_symmetric_key) client_public_key = utils.decrypt_aes(symmetric_session_key, ciphertext) print(client_public_key) print("-------------") # print(utils.decrypt_aes(symmetric_session_key, ciphertext)) # core.add_sender(new_sender(ADDRESS_MC), ADDRESS_MC) # core.send_message_to_address(ADDRESS_MC, "test test") # core.close_connection(ADDRESS_MC)
def run_protocol(n_processes, regions, restricted, instance_type): '''Runs the protocol.''' start = time() parallel = n_processes > 1 if regions == 'badger_regions': regions = badger_regions() if regions == 'all': regions = available_regions() # note: there are only 5 t2.micro machines in 'sa-east-1', 'ap-southeast-2' each color_print('launching machines') nhpr = n_processes_per_regions(n_processes, regions, restricted) launch_new_instances(nhpr, instance_type) color_print('waiting for transition from pending to running') wait('running', regions) color_print('generating keys') # generate signing and keys generate_keys(n_processes) color_print('generating addresses file') # prepare address file ip_list = instances_ip(regions) with open('ip_addresses', 'w') as f: f.writelines([ip + '\n' for ip in ip_list]) color_print('waiting till ports are open on machines') wait('open 22', regions) color_print('installing dependencies') # install dependencies on hosts run_task('inst-dep', regions, parallel) color_print('packing local repo') # pack testing repo with Connection('localhost') as c: zip_repo(c) color_print('wait till installation finishes') # wait till installing finishes wait_install(regions) color_print('sending testing repo') # send testing repo run_task('send-testing-repo', regions, parallel) color_print('syncing files') # send files: addresses, signing_keys, light_nodes_public_keys run_task('sync-files', regions, parallel) color_print('sending parameters') # send parameters run_task('send-params', regions, parallel) color_print(f'establishing the environment took {round(time()-start, 2)}s') color_print('running the experiment') # run the experiment run_task('run-protocol', regions, parallel)
def __init__(self): self.__private_key, self.public_key = generate_keys() self.id = self.public_key
from utils import get_safe_prime_and_generator from utils import generate_keys from utils import sign s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) port = 11111 # connect to the verifier s.connect(('127.0.0.1', port)) #no of bits of security k = 8 #use pre-computed safe prime and generator or generate the pair #prime, generator = 2337337002729225098572093778426340936344769375016804739, 408301515976774063741225363930200775333880949653971216 prime, generator = get_safe_prime_and_generator(k) keys = generate_keys(prime, generator) print('Enter message to apply signature to : ') message = input() signature = sign(message, keys['secret_key'], prime, generator) complete_message = str(prime) + '/' + str(generator) + '/' + str( keys['public_key']) + '/' + message + '/' + str(signature) s.send(complete_message.encode('ascii')) s.close()
import base64 from constants import ADDRESS_CM from constants import ADDRESS_MC from node import Node from node import new_listener from node import new_sender from Crypto.Cipher import AES from Crypto.PublicKey import RSA from Crypto.Cipher import PKCS1_OAEP from os import path import os.path import utils as utils from Crypto.Random import get_random_bytes utils.generate_keys(True) merchant_public_key = utils.load_public_keys(False) client_public_key = utils.load_public_keys(True) # Hybrid encryption of a message m with the key k means that the message m is encrypted using a symmetric session key # s, which is in turn encrypted using an asymmetric key k (the digital envelope). symmetric_session_key = get_random_bytes(32) cipher_asymmetric = PKCS1_OAEP.new(RSA.import_key(merchant_public_key)) encrypted_symmetric_key = cipher_asymmetric.encrypt(symmetric_session_key) ind_1 = client_public_key.find('\n') ind_2 = client_public_key.rfind('\n') client_public_key = client_public_key[ind_1 + 1:ind_2]