mirror of https://github.com/MISP/misp-modules
Modules for expansion services, import and export in MISP
http://misp.github.io/misp-modules
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
214 lines
9.9 KiB
214 lines
9.9 KiB
from pymisp import MISPAttribute, MISPEvent, MISPObject |
|
import json |
|
import requests |
|
|
|
misperrors = {'error': 'Error'} |
|
mispattributes = {'input': ['hostname', 'domain', "ip-src", "ip-dst", "md5", "sha1", "sha256", "sha512", "url"], |
|
'format': 'misp_standard'} |
|
|
|
# possible module-types: 'expansion', 'hover' or both |
|
moduleinfo = {'version': '4', 'author': 'Hannah Ward', |
|
'description': 'Get information from virustotal', |
|
'module-type': ['expansion']} |
|
|
|
# config fields that your code expects from the site admin |
|
moduleconfig = ["apikey"] |
|
|
|
|
|
# TODO: Parse the report with a private API key to be able to get more advanced results from a query with 'allinfo' set to True |
|
|
|
class VirusTotalParser(object): |
|
def __init__(self, apikey): |
|
self.apikey = apikey |
|
self.base_url = "https://www.virustotal.com/vtapi/v2/{}/report" |
|
self.misp_event = MISPEvent() |
|
self.parsed_objects = {} |
|
self.input_types_mapping = {'ip-src': self.parse_ip, 'ip-dst': self.parse_ip, |
|
'domain': self.parse_domain, 'hostname': self.parse_domain, |
|
'md5': self.parse_hash, 'sha1': self.parse_hash, |
|
'sha256': self.parse_hash, 'sha512': self.parse_hash, |
|
'url': self.parse_url} |
|
|
|
def query_api(self, attribute): |
|
self.attribute = MISPAttribute() |
|
self.attribute.from_dict(**attribute) |
|
return self.input_types_mapping[self.attribute.type](self.attribute.value, recurse=True) |
|
|
|
def get_result(self): |
|
event = json.loads(self.misp_event.to_json()) |
|
results = {key: event[key] for key in ('Attribute', 'Object') if (key in event and event[key])} |
|
return {'results': results} |
|
|
|
################################################################################ |
|
#### Main parsing functions #### # noqa |
|
################################################################################ |
|
|
|
def parse_domain(self, domain, recurse=False): |
|
req = requests.get(self.base_url.format('domain'), params={'apikey': self.apikey, 'domain': domain}) |
|
if req.status_code != 200: |
|
return req.status_code |
|
req = req.json() |
|
hash_type = 'sha256' |
|
whois = 'whois' |
|
feature_types = {'communicating': 'communicates-with', |
|
'downloaded': 'downloaded-from', |
|
'referrer': 'referring'} |
|
siblings = (self.parse_siblings(domain) for domain in req['domain_siblings']) |
|
uuid = self.parse_resolutions(req['resolutions'], req['subdomains'], siblings) |
|
for feature_type, relationship in feature_types.items(): |
|
for feature in ('undetected_{}_samples', 'detected_{}_samples'): |
|
for sample in req.get(feature.format(feature_type), []): |
|
status_code = self.parse_hash(sample[hash_type], False, uuid, relationship) |
|
if status_code != 200: |
|
return status_code |
|
if req.get(whois): |
|
whois_object = MISPObject(whois) |
|
whois_object.add_attribute('text', type='text', value=req[whois]) |
|
self.misp_event.add_object(**whois_object) |
|
return self.parse_related_urls(req, recurse, uuid) |
|
|
|
def parse_hash(self, sample, recurse=False, uuid=None, relationship=None): |
|
req = requests.get(self.base_url.format('file'), params={'apikey': self.apikey, 'resource': sample}) |
|
status_code = req.status_code |
|
if req.status_code == 200: |
|
req = req.json() |
|
vt_uuid = self.parse_vt_object(req) |
|
file_attributes = [] |
|
for hash_type in ('md5', 'sha1', 'sha256'): |
|
if req.get(hash_type): |
|
file_attributes.append({'type': hash_type, 'object_relation': hash_type, |
|
'value': req[hash_type]}) |
|
if file_attributes: |
|
file_object = MISPObject('file') |
|
for attribute in file_attributes: |
|
file_object.add_attribute(**attribute) |
|
file_object.add_reference(vt_uuid, 'analyzed-with') |
|
if uuid and relationship: |
|
file_object.add_reference(uuid, relationship) |
|
self.misp_event.add_object(**file_object) |
|
return status_code |
|
|
|
def parse_ip(self, ip, recurse=False): |
|
req = requests.get(self.base_url.format('ip-address'), params={'apikey': self.apikey, 'ip': ip}) |
|
if req.status_code != 200: |
|
return req.status_code |
|
req = req.json() |
|
if req.get('asn'): |
|
asn_mapping = {'network': ('ip-src', 'subnet-announced'), |
|
'country': ('text', 'country')} |
|
asn_object = MISPObject('asn') |
|
asn_object.add_attribute('asn', type='AS', value=req['asn']) |
|
for key, value in asn_mapping.items(): |
|
if req.get(key): |
|
attribute_type, relation = value |
|
asn_object.add_attribute(relation, type=attribute_type, value=req[key]) |
|
self.misp_event.add_object(**asn_object) |
|
uuid = self.parse_resolutions(req['resolutions']) if req.get('resolutions') else None |
|
return self.parse_related_urls(req, recurse, uuid) |
|
|
|
def parse_url(self, url, recurse=False, uuid=None): |
|
req = requests.get(self.base_url.format('url'), params={'apikey': self.apikey, 'resource': url}) |
|
status_code = req.status_code |
|
if req.status_code == 200: |
|
req = req.json() |
|
vt_uuid = self.parse_vt_object(req) |
|
if not recurse: |
|
feature = 'url' |
|
url_object = MISPObject(feature) |
|
url_object.add_attribute(feature, type=feature, value=url) |
|
url_object.add_reference(vt_uuid, 'analyzed-with') |
|
if uuid: |
|
url_object.add_reference(uuid, 'hosted-in') |
|
self.misp_event.add_object(**url_object) |
|
return status_code |
|
|
|
################################################################################ |
|
#### Additional parsing functions #### # noqa |
|
################################################################################ |
|
|
|
def parse_related_urls(self, query_result, recurse, uuid=None): |
|
if recurse: |
|
for feature in ('detected_urls', 'undetected_urls'): |
|
if feature in query_result: |
|
for url in query_result[feature]: |
|
value = url['url'] if isinstance(url, dict) else url[0] |
|
status_code = self.parse_url(value, False, uuid) |
|
if status_code != 200: |
|
return status_code |
|
else: |
|
for feature in ('detected_urls', 'undetected_urls'): |
|
if feature in query_result: |
|
for url in query_result[feature]: |
|
value = url['url'] if isinstance(url, dict) else url[0] |
|
self.misp_event.add_attribute('url', value) |
|
return 200 |
|
|
|
def parse_resolutions(self, resolutions, subdomains=None, uuids=None): |
|
domain_ip_object = MISPObject('domain-ip') |
|
if self.attribute.type == 'domain': |
|
domain_ip_object.add_attribute('domain', type='domain', value=self.attribute.value) |
|
attribute_type, relation, key = ('ip-dst', 'ip', 'ip_address') |
|
else: |
|
domain_ip_object.add_attribute('ip', type='ip-dst', value=self.attribute.value) |
|
attribute_type, relation, key = ('domain', 'domain', 'hostname') |
|
for resolution in resolutions: |
|
domain_ip_object.add_attribute(relation, type=attribute_type, value=resolution[key]) |
|
if subdomains: |
|
for subdomain in subdomains: |
|
attribute = MISPAttribute() |
|
attribute.from_dict(**dict(type='domain', value=subdomain)) |
|
self.misp_event.add_attribute(**attribute) |
|
domain_ip_object.add_reference(attribute.uuid, 'subdomain') |
|
if uuids: |
|
for uuid in uuids: |
|
domain_ip_object.add_reference(uuid, 'sibling-of') |
|
self.misp_event.add_object(**domain_ip_object) |
|
return domain_ip_object.uuid |
|
|
|
def parse_siblings(self, domain): |
|
attribute = MISPAttribute() |
|
attribute.from_dict(**dict(type='domain', value=domain)) |
|
self.misp_event.add_attribute(**attribute) |
|
return attribute.uuid |
|
|
|
def parse_vt_object(self, query_result): |
|
vt_object = MISPObject('virustotal-report') |
|
vt_object.add_attribute('permalink', type='link', value=query_result['permalink']) |
|
detection_ratio = '{}/{}'.format(query_result['positives'], query_result['total']) |
|
vt_object.add_attribute('detection-ratio', type='text', value=detection_ratio) |
|
self.misp_event.add_object(**vt_object) |
|
return vt_object.uuid |
|
|
|
|
|
def parse_error(status_code): |
|
status_mapping = {204: 'VirusTotal request rate limit exceeded.', |
|
400: 'Incorrect request, please check the arguments.', |
|
403: 'You don\'t have enough privileges to make the request.'} |
|
if status_code in status_mapping: |
|
return status_mapping[status_code] |
|
return "VirusTotal may not be accessible." |
|
|
|
|
|
def handler(q=False): |
|
if q is False: |
|
return False |
|
request = json.loads(q) |
|
if not request.get('config') or not request['config'].get('apikey'): |
|
misperrors['error'] = "A VirusTotal api key is required for this module." |
|
return misperrors |
|
parser = VirusTotalParser(request['config']['apikey']) |
|
attribute = request['attribute'] |
|
status = parser.query_api(attribute) |
|
if status != 200: |
|
misperrors['error'] = parse_error(status) |
|
return misperrors |
|
return parser.get_result() |
|
|
|
|
|
def introspection(): |
|
return mispattributes |
|
|
|
|
|
def version(): |
|
moduleinfo['config'] = moduleconfig |
|
return moduleinfo
|
|
|