def _register(self, manager): Module._register(self, manager) self.port = pydra_settings.PORT self.node_key = None #load crypto keys for authentication self.pub_key, self.priv_key = load_crypto('%s/node.key' % \ pydra_settings.RUNTIME_FILES_DIR) self.master_pub_key = load_crypto('%s/node.master.key' % \ pydra_settings.RUNTIME_FILES_DIR, create=False, both=False) self.master = None
def __init__(self): #locks self._lock = Lock() #general lock, use when multiple shared resources are touched self._listeners = { 'MANAGER_INIT':self.connect, 'NODE_CREATED':self.connect_node, 'NODE_UPDATED':self.connect_node, } self._interfaces = [ self.connect ] #load rsa crypto self.pub_key, self.priv_key = load_crypto('%s/master.key' \ % pydra_settings.RUNTIME_FILES_DIR) self.rsa_client = RSAClient(self.priv_key, self.pub_key, \ callback=self.init_node) #connection management self.connecting = True self.reconnect_count = 0 self.attempts = None self.reconnect_call_ID = None self.host = 'localhost'
def __init__(self, key_size=4096, key=None): self._registered_interfaces = {} self.sessions = {} self.key_size = key_size key = key if key else '%s/master.key' % pydra_settings.RUNTIME_FILES_DIR self.pub_key, self.priv_key = load_crypto(key) self.priv_key_encrypt = self.priv_key.encrypt
def __init__(self): self._services = [self.get_worker_service] #locks self._lock = Lock() #general lock, use when multiple shared resources are touched #load rsa crypto self.pub_key, self.priv_key = load_crypto('%s/master.key' % pydra_settings.RUNTIME_FILES_DIR)
def test_load_crypto_key_pair_no_key(self): """ verifies that a key will not be created or loaded when there is no Key file and create flag = False """ self.destroy_key_files() try: priv = load_crypto(KEY_FILE, False, both=False) self.assertFalse(priv, 'Private key should not have been created') finally: self.destroy_key_files()
def __init__(self): self._listeners = {"MANAGER_INIT": self.connect, "WORKER_FINISHED": self.disconnect} self._remotes = [("MASTER", os.getpid)] self.reconnect_count = 0 self.factory = MasterClientFactory(self.reconnect) # load crypto for authentication # workers use the same keys as their parent Node self.pub_key, self.priv_key = load_crypto("%s/node.key" % pydra_settings.RUNTIME_FILES_DIR) # self.master_pub_key = load_crypto('./node.key', False, both=False) self.rsa_client = RSAClient(self.priv_key)
def __init__(self): self._services = [self.get_worker_service] self._listeners = {"NODE_INITIALIZED": self.enable_workers, "WORKER_FINISHED": self.remove_worker} # locks self._lock = Lock() # general lock, use when multiple shared resources are touched # load rsa crypto self.pub_key, self.priv_key = load_crypto("%s/node.key" % pydra_settings.RUNTIME_FILES_DIR) # setup worker security - using this checker just because we need # _something_ that returns an avatarID. Its extremely vulnerable # but thats ok because the real authentication takes place after # the worker has connected self.worker_checker = checkers.InMemoryUsernamePasswordDatabaseDontUse()
def __init__(self, host='localhost', port=18801, key='./master.key'): """ Initialize WebController :parameters: host: host of interface port: port of interface key: path to key file for authentication [./master.key] """ self.host = host self.port = port # load rsa crypto self.pub_key, self.priv_key = load_crypto(key, False) cj = cookielib.CookieJar() self.opener = urllib2.build_opener(urllib2.HTTPCookieProcessor(cj))
def test_load_crypto_public_key(self): """ verifies that a public key can be loaded """ self.destroy_key_files() try: # create keys and save the public key pub, priv = generate_keys(KEY_SIZE) self.create_key_file(pub) #get the public key data back pub_key = load_crypto(KEY_FILE, False, both=False) priv_key = RSA.construct(priv) self.verify_keys(pub_key, priv_key) finally: self.destroy_key_files()
def _register(self, manager): InterfaceModule._register(self, manager) self._services = [self.get_controller_service] #load rsa crypto self.pub_key, self.priv_key = load_crypto('%s/master.key' % \ pydra_settings.RUNTIME_FILES_DIR) self.priv_key_encrypt = self.priv_key.encrypt # setup security. This just uses a default user/pw # the real authentication happens after the AMF client connects self.checker = checkers.InMemoryUsernamePasswordDatabaseDontUse() self.checker.addUser("controller", "1234") # Load crypto - The interface runs on the same server as the Master so # it can use the same key. Theres no way with the AMF interface to # restrict access to localhost connections only. self.key_size=4096
def test_load_crypto_key_pair_no_key_create_key(self): """ Verifies keypair will be generated and returned when there is no key and create flag = True """ self.destroy_key_files() try: pub, priv_key = load_crypto(KEY_FILE, key_size=KEY_SIZE) self.assert_(pub, 'No public key was returned from load_crypto') self.assert_(priv_key, 'No private key was returned from load_crypto') self.assertEqual(len(pub), 2, 'Public key should have 2 integers') pub_key = RSA.construct(pub) self.verify_keys(pub_key, priv_key) finally: self.destroy_key_files()
def setUp(self): load_crypto('./keys') self.api = WebController(key='./keys') self.api.opener = OpenerProxy() self.func = WebControllerFunction(self.api, 'method_name')
def setUp(self): load_crypto('./keys')