Intel471 Malware Feed

Details

ID	`Intel471 Malware Feed`
Provider	Intel 471
Category	Data Enrichment & Threat Intelligence
From Version	5.5.0
Docker Image	`demisto/py3-tools:1.0.0.47433`
Supported Modules	Agentix XSIAM

README

“Intel471’s Malware Intelligence is focused on the provisioning of a high fidelity and timely indicators feed with rich context, TTP information, and malware intelligence reports.
This feed allows customers to block and gain an understanding of the latest crimeware campaigns and is for those that value timeliness, confidence (little to no false positives), and seek rich context and insight around the attacks they are seeing.”

Configure Intel471 Malware Feed in Cortex

Parameter	Description	Required
feed	Fetch indicators	False
credentials	Username	False
feedReputation	Indicator Reputation	False
feedReliability	Source Reliability	True
tlp_color	Traffic Light Protocol Color	False
feedExpirationPolicy		False
feedExpirationInterval		False
feedFetchInterval	Feed Fetch Interval	False
indicator_type	Indicator Type	True
threat_type	Search by Threat Type	False
malware_family	Malware Family	False
confidence	Search by confidence	False
indicator	Free text indicator search (all fields included)	False
fetch_time	First fetch timestamp (`<number>` `<time unit>`, e.g., 12 hours, 7 days)	False
feedTags	Tags	False
feedBypassExclusionList	Bypass exclusion list	False
proxy	Use system proxy settings	False
insecure	Trust any certificate (not secure)	False

Commands

You can execute these commands from the CLI, as part of an automation, or in a playbook.
After you successfully execute a command, a DBot message appears in the War Room with the command details.

intel471-malware-get-indicators

Gets the feed indicators.

Base Command

intel471-malware-get-indicators

Input

Argument Name	Description	Required
limit	The maximum number of results to return. Default is 50.	Optional

Context Output

There is no context output for this command.

Configuration parameters

feed — Fetch indicators
credentials — Username
feedReputation — Indicator Reputation
feedReliability — Source Reliability (required)
tlp_color — Traffic Light Protocol Color
feedExpirationPolicy —
feedExpirationInterval —
feedFetchInterval — Feed Fetch Interval
indicator_type — Indicator Type (required)
threat_type — Search by Threat Type
malware_family — Malware Family
confidence — Search by confidence
indicator — Free text indicator search (all fields included)
fetch_time — First fetch timestamp (<number> <time unit>, e.g., 12 hours, 7 days)
feedTags — Tags
feedBypassExclusionList — Bypass exclusion list
proxy — Use system proxy settings
insecure — Trust any certificate (not secure)

Commands (1)

intel471-malware-get-indicators
Gets the feed indicators.

Source

Intel471Malware.py Intel471Malware_test.py Intel471Malware.yml Intel471Malware_description.md command_examples.txt

Download History Raw

import demistomock as demisto  # noqa: F401
from CommonServerPython import *  # noqa: F401
import jmespath
from JSONFeedApiModule import *  # noqa: E402

DEFAULT_COUNT = 100
SEARCH_PARAMS = {
    "indicator": "indicator",
    "from": "from",
    "until": "until",
    "threat_type": "threatType",
    "malware_family": "malwareFamily",
    "confidence": "confidence",
    "count": "count",
}
FEED_INDICATOR_TYPES = {
    FeedIndicatorType.URL: FeedIndicatorType.URL,
    FeedIndicatorType.File: FeedIndicatorType.File,
    "ipv4": FeedIndicatorType.IP,
}
FEED_URL = "https://api.intel471.com/v1/indicators/stream?"
MAPPING = {
    FeedIndicatorType.File: {
        "threat_type": "threattypes.threatcategory",
        "threat_data_family": "malwarefamily",
        "indicator_data_file_md5": "md5",
        "indicator_data_file_sha1": "sha1",
        "indicator_data_file_sha256": "sha256",
        "context_description": "description",
        "indicator_data_file_download_url": "downloadurl",
        "mitre_tactics": "mitretactics",
    },
    FeedIndicatorType.URL: {
        "threat_type": "threattypes.threatcategory",
        "threat_data_family": "malwarefamily",
        "indicator_data_url": "url",
        "context_description": "description",
        "mitre_tactics": "mitretactics",
    },
    "ipv4": {
        "threat_type": "threattypes.threatcategory",
        "threat_data_family": "malwarefamily",
        "indicator_data_address": "ipaddress",
        "context_description": "description",
        "mitre_tactics": "mitretactics",
    },
}
INDICATOR_VALUE_FIELD = {
    FeedIndicatorType.File: "indicator_data_file_sha256",
    FeedIndicatorType.URL: "indicator_data_url",
    "ipv4": "indicator_data_address",
}
DEMISTO_VERSION = demisto.demistoVersion()
CONTENT_PACK = f"Intel471 Feed/{str(get_pack_version())}"
INTEGRATION = "Intel471 Malware Feed"
USER_AGENT = f'XSOAR/{DEMISTO_VERSION["version"]}.{DEMISTO_VERSION["buildNumber"]} - {CONTENT_PACK} - {INTEGRATION}'


def _create_url(**kwargs):
    url_suffix = ""
    for param in kwargs:
        url_suffix += f"&{param}={kwargs.get(param)}"
    return FEED_URL + url_suffix.strip("&")


def _build_url_parameter_dict(**kwargs):
    """
    Given a set of parameters, creates a dictionary with only searchable items that can be used in api.
    """
    params_dict = {}
    for param in kwargs:
        if param in SEARCH_PARAMS:
            params_dict[SEARCH_PARAMS.get(param)] = kwargs.get(param)
    return params_dict


def get_params_by_indicator_type(**kwargs):
    indicators_url = {}
    params = _build_url_parameter_dict(**kwargs)
    params["count"] = int(params.get("count", DEFAULT_COUNT))

    indicator_types = argToList(kwargs.get("indicator_type"))

    # allows user to choose multiple indicator types at once.
    if "All" in indicator_types:
        indicator_types = FEED_INDICATOR_TYPES

    for current_type in indicator_types:
        params["indicatorType"] = current_type
        indicators_url[current_type] = _create_url(**params)
    return indicators_url


def custom_build_iterator(client: Client, feed: dict, limit: int = 0, **kwargs) -> List:
    url = feed.get("url", client.url)
    fetch_time = feed.get("fetch_time")
    start_date, end_date = parse_date_range(fetch_time, utc=True, to_timestamp=True)
    integration_context = get_integration_context()
    last_fetch = integration_context.get(f"{feed.get('indicator_type')}_fetch_time")
    params = {"lastUpdatedFrom": last_fetch if last_fetch else start_date}
    result: List[dict] = []
    should_continue = True

    while should_continue:
        r = requests.get(
            url=url, verify=client.verify, auth=client.auth, cert=client.cert, headers=client.headers, params=params, **kwargs
        )
        try:
            r.raise_for_status()
            data = r.json()
            current_result = jmespath.search(expression=feed.get("extractor"), data=data)
            if current_result:
                result = result + current_result

            # gets next page reference and handles paging.
            should_continue = len(result) < limit if result else True
            should_continue = should_continue or data.get("cursorNext") != params.get("cursor")
            params["cursor"] = data.get("cursorNext") if should_continue else ""

        except ValueError as VE:
            raise ValueError(f"Could not parse returned data to Json. \n\nError massage: {VE}")

    set_integration_context({f"{feed.get('indicator_type')}_fetch_time": str(end_date)})
    return result


def main():
    params = {k: v for k, v in demisto.params().items() if v is not None}
    params["headers"] = {"user-agent": USER_AGENT}
    urls = get_params_by_indicator_type(**params)
    params["feed_name_to_config"] = {}
    for indicator_type in urls:
        params["feed_name_to_config"][indicator_type] = {
            "url": urls.get(indicator_type),
            "extractor": "indicators[*].data",
            "indicator_type": FEED_INDICATOR_TYPES.get(indicator_type),
            "indicator": INDICATOR_VALUE_FIELD.get(indicator_type),
            "flat_json_with_prefix": True,
            "mapping": MAPPING.get(indicator_type),
            "custom_build_iterator": custom_build_iterator,
            "fetch_time": params.get("fetch_time", "7 days"),
        }
    feed_main(params, "Intel471 Malware Feed", "intel471-malware")


if __name__ in ("__main__", "__builtin__", "builtins"):
    main()

Intel471 Malware Feed Deprecated