def test_get_agent_id(self): """Testing method or function named get_agent_id.""" # Test. Agent_id shouldn't change agent_name = random() expected = files.get_agent_id(agent_name, self.config) result = files.get_agent_id(agent_name, self.config) self.assertEqual(result, expected) # Delete the file, make sure a new ID is generated filename = files.agent_id_file(agent_name, self.config) os.remove(filename) _expected = files.get_agent_id(agent_name, self.config) _result = files.get_agent_id(agent_name, self.config) self.assertEqual(_result, _expected) self.assertNotEqual(expected, _expected)
def __init__(self, agent_program, polling_interval): """Initialize the class. Args: agent_program: Name of agent program collecting the data polling_interval: Polling interval Returns: None Variables: self.data: List of TargetDataPoints objects created by polling self.valid: True if the object contains TargetDataPoints objects """ # Initialize key variables self.agent_program = agent_program self.agent_hostname = socket.getfqdn() self.agent_timestamp = int(time() * 1000) self.data = [] self.valid = False self.agent_polling_interval = polling_interval * 1000 # Get the agent_id from .configuration import Config config = Config() self.agent_id = files.get_agent_id(agent_program, config)
def __init__(self, agent_name, directory=None): """Instantiate the class. Args: agent_name: Name of agent generating the private key directory: Alternative key storage directory Returns: None """ # Initialize key variables config = configuration.Config() self._agent_name = agent_name # Use the agent_id as the email address because it is a unique # identifier across all agents. This allows multiple agents with the # same name to have indepenent sessions. self.email = files.get_agent_id(agent_name, config) # Associate directories if directory is None: # Store keys and keyrings in directories named after the agent. # If the same directory were universally used there could be # conflicts in cases where the API daemon and agents run on the # same server This eliminates this risk. keyring_directory = config.keyring_directory(agent_name) self._keys_directory = config.keys_directory(agent_name) else: keyring_directory = '{}{}.keyring'.format(directory, os.sep) self._keys_directory = directory files.mkdir(directory) files.mkdir(keyring_directory) # Initialize GPG object. Note: options=['--pinentry-mode=loopback'] # ensures the passphrase can be entered via python and won't prompt # the user. self._gpg = gnupg.GPG(gnupghome=keyring_directory, options=['--pinentry-mode=loopback']) # Import metadata for managing keys metadata = self._import() # Create and store metadata if nonexistent if metadata is None: metadata = self._generate(self.email) self._export(metadata) # Share passphrase self._passphrase = metadata.passphrase self._fingerprint = metadata.fingerprint # Get the public key ID self._public_keyid = self._get_public_keyid(metadata.fingerprint)
def test___init__(self): """Testing function __init__.""" # Setup AgentPolledData variable agent_program = 'brown_bear' agent_hostname = socket.getfqdn() polling_interval = 20 apd = AgentPolledData(agent_program, polling_interval) agent_id = files.get_agent_id(agent_program, self.config) # Test self.assertTrue(bool(apd.agent_timestamp)) self.assertEqual(apd.agent_polling_interval, polling_interval * 1000) self.assertEqual(apd.agent_id, agent_id) self.assertEqual(apd.agent_program, agent_program) self.assertEqual(apd.agent_hostname, agent_hostname) self.assertFalse(apd.valid)
def test_pexport(self): """Testing function pexport.""" # Initialize key variables config = configuration.BaseConfig() # Test for _, data_ in self.instances.items(): # Get instance information instance = data_['instance'] email = data_['email'] fingerprint = instance.fingerprint(email) # Create a new instance new_agent = hashlib.md5('{}'.format(random()).encode()).hexdigest() new_email = files.get_agent_id(new_agent, config) new_directory = tempfile.mkdtemp() new_instance = encrypt.Encryption(new_agent, new_directory) new_public_key = new_instance.pexport() new_fingerprint = new_instance.fingerprint(new_email) # There should be only one public key public_key = instance.pexport() # Import public key instance.pimport(new_public_key) result = instance.pexport(new_fingerprint) # There should be a match self.assertEqual(new_public_key, result) self.assertNotEqual(result, public_key) # Test deletion of nonexistent fingerprint status = instance.pdelete('foo') self.assertFalse(status) # Test deletion of primary fingerprint status = instance.pdelete(fingerprint) self.assertFalse(status) # Test deletion of primary fingerprint status = instance.pdelete(new_fingerprint) self.assertTrue(status) result = instance.pexport(new_fingerprint) self.assertIsNone(result) # Delete directory shutil.rmtree(new_directory)
def create_cache(): """Testing method / function records.""" # Initialize key variables config = ServerConfig() polling_interval = 20 cache_directory = config.agent_cache_directory(PATTOO_API_AGENT_NAME) result = { 'pattoo_agent_program': data.hashstring(str(random())), 'pattoo_agent_polled_target': socket.getfqdn(), 'pattoo_key': data.hashstring(str(random())), 'pattoo_value': round(uniform(1, 100), 5), 'pattoo_agent_hostname': socket.getfqdn() } # We want to make sure we get a different AgentID each time filename = files.agent_id_file( result['pattoo_agent_program'], config) if os.path.isfile(filename) is True: os.remove(filename) result['pattoo_agent_id'] = files.get_agent_id( result['pattoo_agent_program'], config) # Setup AgentPolledData apd = AgentPolledData(result['pattoo_agent_program'], polling_interval) # Initialize TargetDataPoints ddv = TargetDataPoints(result['pattoo_agent_hostname']) # Setup DataPoint data_type = DATA_INT variable = DataPoint( result['pattoo_key'], result['pattoo_value'], data_type=data_type) # Add data to TargetDataPoints ddv.add(variable) # Write data to cache apd.add(ddv) cache_dict = converter.posting_data_points( converter.agentdata_to_post(apd)) cache_file = '{}{}cache_test.json'.format(cache_directory, os.sep) with open(cache_file, 'w') as _fp: json.dump(cache_dict, _fp) return result
def _relay(url): """Relay data to pattoo server. Args: url: Pattoo spoked agent URL Returns: None """ # Initialize key variables config = Config() agent_id = files.get_agent_id(PATTOO_AGENT_LINUX_HUBD, config) # Initialize key variables passive = PassiveAgent(PATTOO_AGENT_LINUX_HUBD, agent_id, url) passive.relay()
def setUp(self): """Run these steps before each test is performed.""" # Initialize key variables config = configuration.BaseConfig() # Setup encryption instances self.instances = defaultdict(lambda: defaultdict(dict)) directory = tempfile.mkdtemp() for item in range(2): agent = hashlib.md5('{}'.format(random()).encode()).hexdigest() email = files.get_agent_id(agent, config) self.instances[item]['directory'] = directory self.instances[item]['agent'] = agent self.instances[item]['email'] = email self.instances[item]['instance'] = encrypt.Encryption( agent, directory)