def send_mitigation_action_by_mac(self, mac_address, action):
"""
Send an EPS mitigation action for an endpoint MAC address.
:param str mac_address: MAC address of the endpoint for which the
action should be performed.
:param dxlciscopxgridclient.constants.EpsAction action: The action to
perform.
:return: Results of the attempt to send the action. The results for a
successful send should look similar to this:
.. code-block:: json
{
"gid": "150",
"macInterface": "00:11:22:33:44:55",
"mitigationStatus": "complete"
}
:rtype: dict
"""
request = Request(self._EPS_SEND_MITIGATION_ACTION_BY_MAC)
MessageUtils.dict_to_json_payload(request, {
_PARAM_MAC: mac_address,
_PARAM_ACTION: action
})
return MessageUtils.json_payload_to_dict(
self._pxgrid_client._dxl_sync_request(request))
def retrieve_policy_by_name(self, policy_name):
"""
Retrieve information for an ANC policy by name.
:param str policy_name: Name of the policy.
:return: The policy information, which should look similar to this:
.. code-block:: json
{
"ancStatus": "success",
"ancpolicy": [
{
"action": [
"Quarantine"
],
"name": "quarantine_policy"
}
]
}
:rtype: dict
:raises Exception: If the policy name has not been defined.
"""
request = Request(self._ANC_RETRIEVE_POLICY_BY_NAME)
MessageUtils.dict_to_json_payload(request,
{_PARAM_POLICY_NAME: policy_name})
return MessageUtils.json_payload_to_dict(
self._pxgrid_client._dxl_sync_request(request))
def send_mitigation_action_by_ip(self, ip_address, action):
"""
Send an EPS mitigation action for an endpoint IP address.
:param str ip_address: IP address of the endpoint for which the action
should be performed.
:param dxlciscopxgridclient.constants.EpsAction action: The action to
perform.
:return: Results of the attempt to send the action. The results for a
successful send should look similar to this:
.. code-block:: json
{
"gid": "150",
"macInterface": "00:11:22:33:44:55",
"mitigationStatus": "complete"
}
:rtype: dict
:raises Exception: If no session has been established for an endpoint
which corresponds to the IP address.
"""
request = Request(self._EPS_SEND_MITIGATION_ACTION_BY_IP)
MessageUtils.dict_to_json_payload(request, {
_PARAM_IP: ip_address,
_PARAM_ACTION: action,
"foo": "bar"
})
return MessageUtils.json_payload_to_dict(
self._pxgrid_client._dxl_sync_request(request))
def test_callback_statsremained(self):
with MockServerRunner() as server_runner:
with UrlVoidApiService(TEST_FOLDER) as urlvoid_service:
urlvoid_service.URL_VOID_API_URL_FORMAT = "http://127.0.0.1:" \
+ str(server_runner.mock_server_port) \
+ "/api1000/{0}/"
urlvoid_service.run()
request_topic = UrlVoidApiService.REQ_TOPIC_STATS_REMAINED
req = Request(request_topic)
MessageUtils.dict_to_json_payload(
req,
{
UrlVoidApiCallback.PARAM_HOST: SAMPLE_HOST
}
)
res = urlvoid_service._dxl_client.sync_request(req, timeout=30)
self.assertEqual(
dicttoxml(
SAMPLE_REMAINED_OUTPUT,
custom_root=XML_ROOT_RESPONSE,
attr_type=False
),
res.payload
)
def _request(self, dxl_request, path, request_fn, body=None):
"""
Make a request to TheHive server, delivering the response to the
DXL fabric.
:param dxlclient.message.Request dxl_request: DXL request containing
parameters to forward along in a request to TheHive server.
:param str path: URL subpath for the request to send to TheHive server.
:param function request_fn: Callback which is invoked to make
TheHive request.
:param str body: Request body to include in the request.
"""
try:
request_url = self._api_url + path
response = request_fn(request_url, body)
if 200 <= response.status_code <= 299:
# TheHive request was successful so forward the response
# along as-is to the DXL fabric.
res = Response(dxl_request)
MessageUtils.dict_to_json_payload(res, response.json())
else:
# TheHive request encountered an error. Attempt to decode
# an error message from the response body.
res = self._build_http_error_response(dxl_request, response)
except Exception as ex:
error_str = str(ex)
logger.exception("Error handling request: %s", error_str)
res = ErrorResponse(dxl_request,
error_message=MessageUtils.encode(error_str))
self._dxl_client.send_response(res)
def get_endpoint_by_mac(self, mac_address):
"""
Get information for an endpoint by its MAC address.
:param str mac_address: MAC address of the endpoint.
:return: The endpoint information, which should look similar to this:
.. code-block:: json
{
"ancEndpoint": [
{
"macAddress": "00:11:22:33:44:55",
"policyName": "quarantine_policy"
}
],
"ancStatus": "success"
}
:rtype: dict
:raises Exception: If no policy has been associated with the endpoint.
"""
request = Request(self._ANC_GET_ENDPOINT_BY_MAC)
MessageUtils.dict_to_json_payload(request, {_PARAM_MAC: mac_address})
return MessageUtils.json_payload_to_dict(
self._pxgrid_client._dxl_sync_request(request))
def on_request(self, request):
"""
Invoked when a request message is received.
:param request: The request message
"""
# Handle request
logger.info("Request received on topic: '%s' with payload: '%s'",
request.destination_topic,
MessageUtils.decode_payload(request))
try:
res = Response(request)
request_dict = MessageUtils.json_payload_to_dict(request) \
if request.payload else {}
# Ensure required parameters are present
if self._required_params:
for name in self._required_params:
if name not in request_dict:
raise Exception(
"Required parameter not found: '{}'".format(name))
if "format" not in request_dict:
request_dict["format"] = "json"
elif request_dict["format"] not in ("json", "xml"):
raise Exception(
"Unsupported format requested: '{}'. {}".format(
request_dict["format"],
"Only 'json' and 'xml' are supported."))
# Invoke DomainTools API via client
dt_response = \
getattr(self._app.domaintools_api,
self._func_name)(**request_dict)
# Set response payload
response_data = dt_response.data()
if isinstance(response_data, dict):
MessageUtils.dict_to_json_payload(res, response_data)
else:
MessageUtils.encode_payload(res, response_data)
except ServiceException as ex:
logger.exception("Error handling request")
msg = "%s: %s" % (ex.__class__.__name__, ex.reason)
res = ErrorResponse(request,
error_message=MessageUtils.encode(msg))
except Exception as ex:
logger.exception("Error handling request")
msg = str(ex)
if not msg:
msg = ex.__class__.__name__
res = ErrorResponse(request,
error_message=MessageUtils.encode(msg))
# Send response
self._app.client.send_response(res)
def _sync_request(dxl_client, request, response_timeout, payload_dict):
"""
Performs a synchronous DXL request and returns the payload
:param dxl_client: The DXL client with which to perform the request
:param request: The DXL request to send
:param response_timeout: The maximum amount of time to wait for a response
:param payload_dict: The dictionary (``dict``) to use as the payload of the DXL request
:return: The result of the remote command execution (resulting payload)
"""
# Set the payload
MessageUtils.dict_to_json_payload(request, payload_dict)
# Display the request that is going to be sent
logger.debug(
"Request:\n%s",
MessageUtils.dict_to_json(payload_dict, pretty_print=True))
# Send the request and wait for a response (synchronous)
res = dxl_client.sync_request(request, timeout=response_timeout)
if res.message_type == Message.MESSAGE_TYPE_ERROR:
raise Exception("Error: " + res.error_message + " (" +
str(res.error_code) + ")")
# Return a dictionary corresponding to the response payload
ret_val = MessageUtils.decode_payload(res)
# Display the response
logger.debug("Response:\n%s", ret_val)
return ret_val
def test_callback_parkeddomain(self):
with BaseClientTest.create_client(max_retries=0) as dxl_client:
dxl_client.connect()
with MockServerRunner() as server_runner:
with ApiVoidService(TEST_FOLDER) as apivoid_service:
apivoid_service._dxl_client = dxl_client
apivoid_service.API_VOID_URL_FORMAT = "http://127.0.0.1:" \
+ str(server_runner.mock_server_port) \
+ "/{0}/v1/pay-as-you-go/{1}"
apivoid_service.run()
request_topic = ApiVoidService.REQ_TOPIC_PARKED_DOMAIN
req = Request(request_topic)
MessageUtils.dict_to_json_payload(
req, {ApiVoidCallback.PARAM_HOST: SAMPLE_HOST})
res = apivoid_service._dxl_client.sync_request(req,
timeout=30)
res_dict = MessageUtils.json_payload_to_dict(res)
self.assertDictEqual(SAMPLE_PARKED_DOMAIN, res_dict)
def _invoke_service(self, request_method, request_dict):
"""
Invokes a request method on the MISP DXL service.
:param str request_method: The request method to append to the
topic for the request.
:param dict request_dict: Dictionary containing request information.
:return: Results of the service invocation.
:rtype: dict
"""
if self._misp_service_unique_id:
request_service_id = "/{}".format(self._misp_service_unique_id)
else:
request_service_id = ""
# Create the DXL request message.
request = Request("{}{}/{}".format(self._SERVICE_TYPE,
request_service_id, request_method))
# Set the payload on the request message (Python dictionary to JSON
# payload).
MessageUtils.dict_to_json_payload(request, request_dict)
# Perform a synchronous DXL request.
response = self._dxl_sync_request(request)
# Convert the JSON payload in the DXL response message to a Python
# dictionary and return it.
return MessageUtils.json_payload_to_dict(response)
def on_request(self, request):
"""
Invoked when a request message is received.
:param request: The request message
"""
# Handle request
logger.info("Request received on topic: '{0}' with payload: '{1}'".format(
request.destination_topic, MessageUtils.decode_payload(request)))
try:
# Parameters
nmap_params = MessageUtils.json_payload_to_dict(request)
logger.info("[1/2] Requested NMAP action ({0}) for request {1} is under processing...".format(
MessageUtils.decode_payload(request), request.message_id))
# Create a report from Nmap tool execution
nmap_response = self._do_nmap_scan(nmap_params, request)
logger.info("[2/2] Requested NMAP action was processed successfully for request {0}."
" Preparing response...".format(request.message_id))
# Create response
res = Response(request)
# Set payload
MessageUtils.dict_to_json_payload(res, nmap_response)
# Send response
self._app.client.send_response(res)
logger.info("Sending response for request {0}".format(request.message_id))
except Exception as ex:
logger.exception("Error handling request")
err_res = ErrorResponse(request, MessageUtils.encode(str(ex)))
self._app.client.send_response(err_res)
def on_request(self, request):
"""
Invoked when a request message is received.
:param dxlclient.message.Request request: The request message
"""
# Handle request
logger.debug("Request received on topic: '%s'",
request.destination_topic)
try:
# Create response
res = Response(request)
# Store the next segment.
result = self._store_manager.store_segment(request)
# Set payload
MessageUtils.dict_to_json_payload(res, result.to_dict())
# Send response
self._dxl_client.send_response(res)
except Exception as ex:
logger.exception("Error handling request")
err_res = ErrorResponse(request, error_code=0,
error_message=MessageUtils.encode(str(ex)))
self._dxl_client.send_response(err_res)
def apply_endpoint_policy_by_mac(self, mac_address, policy_name):
"""
Apply a policy to an endpoint by its MAC address.
:param str mac_address: MAC address of the endpoint.
:param str policy_name: Name of the policy to apply.
:return: Results of the attempt to apply the endpoint policy. On a
successful application, the results should look similar to this:
.. code-block:: json
{
"ancStatus": "success"
}
:rtype: dict
:raises Exception: If the supplied policy name has already been
applied to the endpoint or the policy name has not been defined.
"""
request = Request(self._ANC_APPLY_ENDPOINT_POLICY_BY_MAC)
MessageUtils.dict_to_json_payload(request, {
_PARAM_MAC: mac_address,
_PARAM_POLICY_NAME: policy_name
})
return MessageUtils.json_payload_to_dict(
self._pxgrid_client._dxl_sync_request(request))
def on_request(self, request):
"""
Callback invoked when a request is received.
:param dxlclient.message.Request request: The request
"""
logger.info("Request received on topic '%s'",
request.destination_topic)
logger.debug("Payload for topic %s: %s", request.destination_topic,
request.payload)
try:
request_dict = MessageUtils.json_payload_to_dict(request) \
if request.payload else {}
if "event" in request_dict and \
type(request_dict["event"]).__name__ in ("str", "unicode") and \
request_dict["event"].isdigit():
request_dict["event"] = int(request_dict["event"])
response_data = self._api_method(**request_dict)
if isinstance(response_data, dict) and \
response_data.get("errors", None):
res = ErrorResponse(request,
error_message=str(
response_data["errors"][0]))
else:
res = Response(request)
MessageUtils.dict_to_json_payload(res, response_data)
except Exception as ex:
error_str = str(ex)
logger.exception("Error handling request: %s", error_str)
res = ErrorResponse(request,
error_message=MessageUtils.encode(error_str))
self._app.client.send_response(res)
def on_request(self, request):
"""
Invoked when a request message is received.
:param request: The request message
"""
request_payload = MessageUtils.json_payload_to_dict(request)
try:
res = Response(request)
payload = {"code": 200, "body": {}}
if request_payload["target"] == "/v1/simple":
payload = self.v1_simple(request_payload, payload)
else:
payload = self.v1_complex(request_payload, payload)
MessageUtils.dict_to_json_payload(res, payload)
self._client.send_response(res)
except Exception as ex:
err_res = ErrorResponse(request,
error_code=0,
error_message=MessageUtils.encode(str(ex)))
self._client.send_response(err_res)
def set_certificate_reputation(self, trust_level, sha1, public_key_sha1=None, comment=""):
"""
Sets the "Enterprise" reputation (`trust level`) of a specified certificate (as identified by hashes).
.. note::
**Client Authorization**
The OpenDXL Python client invoking this method must have permission to send messages to the
``/mcafee/service/tie/cert/reputation/set`` topic which is part of the
``TIE Server Set Enterprise Reputation`` authorization group.
The following page provides an example of authorizing a Python client to send messages to an
`authorization group`. While the example is based on McAfee Active Response (MAR), the
instructions are the same with the exception of swapping the ``TIE Server Set Enterprise Reputation``
`authorization group` in place of ``Active Response Server API``:
`<https://opendxl.github.io/opendxl-client-python/pydoc/marsendauth.html>`_
**Example Usage**
.. code-block:: python
# Set the enterprise reputation (trust level) for the certificate to Known Trusted
tie_client.set_certificate_reputation(
TrustLevel.KNOWN_TRUSTED,
"1C26E2037C8E205B452CAB3565D696512207D66D",
public_key_sha1="B4C3B2D596D1461C1BB417B92DCD74817ABB829D",
comment="Reputation set via OpenDXL")
:param trust_level: The new `trust level` for the file. The list of standard `trust levels` can be found in the
:class:`dxltieclient.constants.TrustLevel` constants class.
:param sha1: The SHA-1 of the certificate
:param public_key_sha1: The SHA-1 of the certificate's public key (optional)
:param comment: A comment to associate with the certificate (optional)
"""
# Create the request message
req = Request(TIE_SET_CERT_REPUTATION_TOPIC)
# Create a dictionary for the payload
payload_dict = {
"trustLevel": trust_level,
"providerId": CertProvider.ENTERPRISE,
"comment": comment,
"hashes": [
{"type": "sha1", "value": self._hex_to_base64(sha1)}
]}
# Add public key SHA-1 (if specified)
if public_key_sha1:
payload_dict["publicKeySha1"] = self._hex_to_base64(
public_key_sha1)
# Set the payload
MessageUtils.dict_to_json_payload(req, payload_dict)
# Send the request
self._dxl_sync_request(req)
def _get_agents(self, request, request_payload):
hash_match_result = self._get_reputation_for_hashes(
request_payload["hashes"])
metadata = self.REPUTATION_METADATA[hash_match_result]
res = Response(request)
payload = {"agents": metadata["agents"]} if "agents" in metadata else {}
MessageUtils.dict_to_json_payload(res, payload)
self._app.client.send_response(res)
def _set_item_reputation(self, request, request_payload,
change_topic, tags=None):
new_entry = None
hash_match_result = self._get_reputation_for_hashes(
request_payload["hashes"], False)
if hash_match_result:
metadata = self.REPUTATION_METADATA[hash_match_result]
new_reputations = metadata["reputations"]
for reputation_entry in new_reputations:
if reputation_entry["providerId"] == request_payload["providerId"]:
new_entry = reputation_entry
else:
first_hash = request_payload["hashes"][0]
item_name = first_hash["type"] + ":" + first_hash["value"]
new_reputations = []
self.REPUTATION_METADATA[item_name] = {
"hashes": {new_hash["type"]: new_hash["value"] \
for new_hash in request_payload["hashes"]},
"reputations": new_reputations}
metadata = self.REPUTATION_METADATA[item_name]
self._set_hash_algos_for_item(item_name, metadata["hashes"])
tags = tags or {}
if "comment" in request_payload:
tags["comment"] = request_payload["comment"]
metadata["tags"] = tags
old_reputations = copy.deepcopy(new_reputations)
if not new_entry:
new_entry = {"attributes": {},
"providerId": request_payload["providerId"]}
new_entry["trustLevel"] = request_payload["trustLevel"]
new_entry["createDate"] = int(time.time())
new_reputations.append(new_entry)
self._app.client.send_response(Response(request))
event = Event(change_topic)
event_payload = {
"hashes": request_payload["hashes"],
"oldReputations": {"reputations": old_reputations},
"newReputations": {"reputations": new_reputations},
"updateTime": int(time.time())
}
if "publicKeySha1" in metadata["hashes"]:
event_payload["publicKeySha1"] = metadata["hashes"]["publicKeySha1"]
event_payload["hashes"] = filter(
lambda hash_entry: hash_entry["type"] != "publicKeySha1",
event_payload["hashes"]
)
if "relationships" in metadata:
event_payload["relationships"] = metadata["relationships"]
MessageUtils.dict_to_json_payload(event, event_payload)
self._app.client.send_event(event)
def _set_item_reputation(self, request, request_payload, item_name,
change_topic):
new_entry = None
if item_name in self.REPUTATION_METADATA:
new_reputations = self.REPUTATION_METADATA[item_name][
"reputations"]
for reputation_entry in new_reputations:
if reputation_entry["providerId"] == request_payload[
"providerId"]:
new_entry = reputation_entry
else:
new_reputations = []
self.REPUTATION_METADATA[item_name] = {
"hashes": {},
"reputations": new_reputations
}
old_reputations = copy.deepcopy(new_reputations)
old_hashes = self.REPUTATION_METADATA[item_name]["hashes"]
for hash_type, hash_value in old_hashes.items():
if hash_type in self.hash_algos_to_files and \
hash_value in self.hash_algos_to_files[hash_type]:
del self.hash_algos_to_files[hash_type][hash_value]
new_hashes = {new_hash["type"]: new_hash["value"] \
for new_hash in request_payload["hashes"]}
self._set_hash_algos_for_item(item_name, new_hashes)
self.REPUTATION_METADATA[item_name]["hashes"] = new_hashes
if not new_entry:
new_entry = {
"attributes": {},
"providerId": request_payload["providerId"]
}
new_entry["trustLevel"] = request_payload["trustLevel"]
new_entry["createDate"] = int(time.time())
new_reputations.append(new_entry)
self._client.send_response(Response(request))
event = Event(change_topic)
event_payload = {
"hashes": request_payload["hashes"],
"oldReputations": {
"reputations": old_reputations
},
"newReputations": {
"reputations": new_reputations
},
"updateTime": int(time.time())
}
MessageUtils.dict_to_json_payload(event, event_payload)
self._client.send_event(event)
def on_request(self, request):
try:
res = Response(request)
result = self._store_manager.store_segment(request)
MessageUtils.dict_to_json_payload(res, result.to_dict())
self._dxl_client.send_response(res)
except Exception as ex:
err_res = ErrorResponse(request,
error_message=MessageUtils.encode(str(ex)))
self._dxl_client.send_response(err_res)
def _get_item_first_instance(self, request, request_payload):
hash_match_result = self._get_reputation_for_hashes(
request_payload["hashes"])
metadata = self.REPUTATION_METADATA[hash_match_result]
res = Response(request)
if "agents" in metadata:
payload = {
"totalCount": len(metadata["agents"]),
"agents": metadata["agents"]
}
else:
payload = {}
MessageUtils.dict_to_json_payload(res, payload)
self._client.send_response(res)
def _invoke_service(self, request_method, request_dict):
"""
Invokes a request method on the Elasticsearch DXL service.
:param str request_method: The request method to append to the
topic for the request.
:param dict request_dict: Dictionary containing request information.
:return: Results of the service invocation.
:rtype: dict
"""
if self._elasticsearch_service_unique_id:
request_service_id = "/{}".format(
self._elasticsearch_service_unique_id)
else:
request_service_id = ""
# Create the DXL request message.
request = Request("{}{}/{}".format(
self._SERVICE_TYPE,
request_service_id,
request_method))
# Set the payload on the request message (Python dictionary to JSON
# payload).
MessageUtils.dict_to_json_payload(request, request_dict)
# Perform a synchronous DXL request.
response = self._dxl_client.sync_request(request,
timeout=self.response_timeout)
if response.message_type == Message.MESSAGE_TYPE_ERROR:
try:
self._raise_exception_for_error_response(
MessageUtils.json_payload_to_dict(response))
except ValueError:
# If an appropriate exception cannot be constructed from the
# error response data, raise a more generic Exception as a
# fallback.
raise Exception("Error: {} ({})".format(
response.error_message,
str(response.error_code)))
# Convert the JSON payload in the DXL response message to a Python
# dictionary and return it.
return MessageUtils.json_payload_to_dict(response)
def _get_reputation(self, request, request_payload):
hash_match_result = self._get_reputation_for_hashes(
request_payload["hashes"])
res = Response(request)
payload = {
"props": {
"serverTime": int(time.time()),
"submitMetaData": 1
},
"reputations":
self.REPUTATION_METADATA[hash_match_result]["reputations"],
}
MessageUtils.dict_to_json_payload(res, payload)
self._client.send_response(res)
def test_callback_urlscan(self):
with MockServerRunner() as server_runner, \
VirusTotalApiService(TEST_FOLDER) as vt_service:
vt_service.VTAPI_URL_FORMAT = "http://127.0.0.1:" \
+ str(server_runner.mock_server_port) \
+ "/vtapi/v2{0}"
vt_service.run()
request_topic = VirusTotalApiService.REQ_TOPIC_URL_SCAN
req = Request(request_topic)
MessageUtils.dict_to_json_payload(
req, {VirusTotalApiRequestCallback.PARAM_URL: SAMPLE_URL})
res = vt_service._dxl_client.sync_request(req, timeout=30)
res_dict = MessageUtils.json_payload_to_dict(res)
self.assertDictEqual(SAMPLE_URL_SCAN, res_dict)
def on_request(self, request):
"""
Invoked when a request message is received.
:param request: The request message
"""
# Handle request
logger.info("Request received on topic: '%s' with payload: '%s'",
request.destination_topic,
MessageUtils.decode_payload(request))
try:
# Retrieve the parameters from the request
params = MessageUtils.json_payload_to_dict(request)
if self._PARAM_HOST not in params:
raise Exception(
"Required parameter not specified: '{0}'".format(
self._PARAM_HOST))
target = params[self._PARAM_HOST]
ipaddr = socket.gethostbyname(target)
logger.debug("IP to be located: %s", ipaddr)
# Lookup the IP/host
results = self._app.database.lookup_ip(ipaddr)
logger.debug(results)
# Create response
res = Response(request)
# Set payload
MessageUtils.dict_to_json_payload(res, results)
# Send response
self._app.client.send_response(res)
except Exception as ex:
logger.exception("Error handling request")
err_res = ErrorResponse(request,
error_code=0,
error_message=MessageUtils.encode(str(ex)))
self._app.client.send_response(err_res)
def _build_http_error_response(dxl_request, response):
"""
Create a DXL ErrorResponse from the contents of an HTTP response
for a request sent to TheHive.
:param dxlclient.message.Request dxl_request: DXL request containing
parameters to forward along in a request to TheHive server.
:param requests.Response response: HTTP response received from TheHive.
:return: The error response to deliver to the DXL fabric.
:rtype: dxlclient.message.ErrorResponse
"""
response_dict = response.json()
error_message = response_dict.get("message")
if not error_message:
errors = response_dict.get("errors")
if errors:
first_error = errors[0]
if isinstance(first_error, dict):
error_message = first_error.get("message")
elif isinstance(first_error, list):
first_suberror = first_error[0]
if isinstance(first_suberror, dict):
error_message = first_suberror.get(
"message")
if error_message:
log_message = "Error handling request: {}".format(
error_message
)
else:
# Short error message could not be read from the
# response body, so just set a generic description for
# the error message in the DXL response.
error_message = "Error handling request"
log_message = error_message
logger.error(log_message)
res = ErrorResponse(
dxl_request,
error_message=error_message \
if error_message else "Error handling request",
error_code=response.status_code
)
MessageUtils.dict_to_json_payload(res, response_dict)
return res
def lookup_host(self, host):
"""
Looks up Geolocation information for the specified host/IP
:param host: The host/IP to lookup
:return: A dictionary (``dict``) containing the details of the Geolocation lookup
"""
# Create the DXL request message
request = Request(self.HOST_LOOKUP_TOPIC)
# Set the payload on the request message (Python dictionary to JSON payload)
MessageUtils.dict_to_json_payload(request, {self._PARAM_HOST: host})
# Perform a synchronous DXL request
response = self._dxl_sync_request(request)
# Convert the JSON payload in the DXL response message to a Python dictionary
# and return it.
return MessageUtils.json_payload_to_dict(response)
def _sync_request(dxl_client, request, response_timeout, payload_dict):
"""
Performs a synchronous DXL request and returns the payload
:param dxl_client: The DXL client with which to perform the request
:param request: The DXL request to send
:param response_timeout: The maximum amount of time to wait for a response
:param payload_dict: The dictionary (``dict``) to use as the payload of the DXL request
:return: The result of the remote command execution (resulting payload)
"""
# Set the payload
MessageUtils.dict_to_json_payload(request, payload_dict)
# Display the request that is going to be sent
logger.debug("Request:\n%s",
MessageUtils.dict_to_json(payload_dict,
pretty_print=True))
# Send the request and wait for a response (synchronous)
return dxl_client.sync_request(request, timeout=response_timeout)
def clear_endpoint_policy_by_mac(self, mac_address):
"""
Clear the policy for an endpoint by its MAC address.
:param str mac_address: MAC address of the endpoint.
:return: Results of the attempt to clear the endpoint policy. On a
successful clear attempt, the results should look similar to this:
.. code-block:: json
{
"ancStatus": "success"
}
:rtype: dict
:raises Exception: If no policy has been associated with the endpoint.
"""
request = Request(self._ANC_CLEAR_ENDPOINT_POLICY_BY_MAC)
MessageUtils.dict_to_json_payload(request, {_PARAM_MAC: mac_address})
return MessageUtils.json_payload_to_dict(
self._pxgrid_client._dxl_sync_request(request))
def _invoke_service(self, req_dict, topic):
"""
Invokes the DXL Nmap service.
:param req_dict: Dictionary containing request information
:param topic: The Nmap DXL topic to invoke
:return: A dictionary containing the response
"""
# Create the DXL request message
request = Request(topic)
# Set the payload on the request message (Python dictionary to JSON
# payload)
MessageUtils.dict_to_json_payload(request, req_dict)
# Perform a synchronous DXL request
response = self._dxl_sync_request(request)
# Convert the JSON payload in the DXL response message to a Python
# dictionary and return it.
return MessageUtils.json_payload_to_dict(response)