Mimecast

Find Remediation Incidents

Description

This endpoint can be used to search for existing remediation incidents. While each request field is optional, at least one field must be supplied.

Pre-requisites

  • In order to successfully use this endpoint the logged in user must be a Mimecast administrator with at least the Services | Threat Remediation | Read permission.

URI

To use this endpont you send a POST request to:

  • /api/ttp/remediation/find-incidents

Request Headers

The following request headers must be included in your request:

Field Description
Authorization Please see the Authorization guide for more information on building the Authorization header.
x-mc-req-id

A randomly generated GUID, for example,

8578FCFC-A305-4D9A-99CB-F4D5ECEFE297
x-mc-app-id The Application ID provided with your Registered API Application.
x-mc-date

The current date and time in the following format, for example,

Tue, 24 Nov 2015 12:50:11 UTC

Request Body

{
 "data": [
  {
   "start": "2015-11-16T14:49:18+0000", 
   "searchBy": [
    {
     "fieldName": "String", 
     "value": "String"
    }
   ], 
   "end": "2015-11-16T14:49:18+0000", 
   "filterBy": [
    {
     "fieldName": "String", 
     "value": "String"
    }
   ]
  }
 ]
}
data
Field Type Required Description
searchBy Object Optioneel Object data used to filter results
start Date String Optioneel The date and time of the earliest incident to return, in the following format, 2011-12-03T10:15:30+0000
end Date String Optioneel The date and time of the latest incident to return, in the following format, 2011-12-03T10:15:30+0000
filterBy Array Optioneel Filter options to narrow results based on incident type
searchBy
Field Type Required Description
value String Optioneel The text used to filter results
fieldName String Optioneel Incident fields to filter based on. Possible values are: all, code, file_hash, reason
filterBy
Field Type Required Description
type String Optioneel Specify the type of incidents to return. Possible values are: notify_only, automatic, manual or restore

Response

{
 "fail": [], 
 "meta": {
  "status": 200
 }, 
 "data": [
  {
   "incidents": [
    {
     "code": "String", 
     "successful": 1, 
     "modified": "Date String", 
     "reason": "String", 
     "id": "String", 
     "create": "Date String", 
     "identified": 1, 
     "searchCriteria": {
      "start": "Date String", 
      "end": "Date String", 
      "fileHash": "String"
     }, 
     "failed": 0, 
     "type": "String", 
     "restored": 0
    }
   ]
  }
 ]
}
meta object
Field Type Description
status Number The function level status of the request.
meta
Field Type Description
status Number The function level status of the request.
data
Field Type Description
incidents Array An array of incidents
incidents
Field Type Description
code String The remediation incident unique code
type String The incident type. Possible values are notify_only, automatic, manual or restored
reason String The reason provided when the remediation incident was created
searchCriteria searchCritera object Criteria used to when the remediation incident was created
create Date String The time stamp of the incident creation
modified Date String The time stamp of the last modification to the incident
identified Number The total number of messages identified as part of the remediation incident
successful Number The number of messages sucessfully rememdiated
failed Number The number of messages that failed to remediate
restored Number The number of messages restored from the remediation incident
id String The Mimecast secure id of the remediation incident
searchCriteria
Field Type Description
unremediateCode String code required to perform a message restoration
start Date String Date of oldest results to return
end Date String Date of most recent incidents to return
fileHash String File hash used to create remediation incident
messageId String Message id used to create remediation incident
restoreCode String Restore code for remediation event
from String Sender address or domain name used to create remediation incident
to String Recipient address or domain name used to create remediation incident

Sample Code

Sample code is provided to demonstrate how to use the API and is not representative of a production application. To use the sample code; complete the required variables as described, populate the desired values in the request body, and execute in your favorite IDE.  Please see the Global Base URL's page to find the correct base URL to use for your account.

POST {base_url}/api/ttp/remediation/find-incidents
Authorization: MC {accesskKey}:{Base64 encoded signed Data To Sign}
x-mc-date: {dateTime}
x-mc-req-id: {unique id}
x-mc-app-id: {applicationId}
Content-Type: application/json
Accept: application/json


{
  "data":[
    {
        "data":[
            {
                "searchBy": {
                    "value": "String",
                    "fieldName": "String"
                },
                "start": "2015-11-16T14:49:18+0000",
                "end": "2015-11-16T14:49:18+0000",
                "filterBy": {
                    "value": "String",
                    "fieldName": "String"
                }
            }
        ]
    }
  ]
}
import base64
import hashlib
import hmac
import uuid
import datetime
import requests

# Setup required variables
base_url = "https://xx-api.mimecast.com"
uri = "/api/ttp/remediation/find-incidents"
url = base_url + uri
access_key = "YOUR ACCESS KEY"
secret_key = "YOUR SECRET KEY"
app_id = "YOUR APPLICATION ID"
app_key = "YOUR APPLICATION KEY"

# Generate request header values
request_id = str(uuid.uuid4())
hdr_date = datetime.datetime.utcnow().strftime("%a, %d %b %Y %H:%M:%S") + " UTC"

# Create the HMAC SHA1 of the Base64 decoded secret key for the Authorization header
hmac_sha1 = hmac.new(secret_key.decode("base64"), ':'.join([hdr_date, request_id, uri, app_key]),
                  digestmod=hashlib.sha1).digest()

# Use the HMAC SHA1 value to sign the hdrDate + ":" requestId + ":" + URI + ":" + appkey
sig = base64.encodestring(hmac_sha1).rstrip()

# Create request headers
headers = {
    'Authorization': 'MC ' + access_key + ':' + sig,
    'x-mc-app-id': app_id,
    'x-mc-date': hdr_date,
    'x-mc-req-id': request_id,
    'Content-Type': 'application/json'
}

payload = {
        'data': [
            {
                "searchBy": {
                    "value": "String",
                    "fieldName": "String"
                },
                "start": "2015-11-16T14:49:18+0000",
                "end": "2015-11-16T14:49:18+0000",
                "filterBy": {
                    "value": "String",
                    "fieldName": "String"
                }
            }
        ]
    }

r = requests.post(url=url, headers=headers, data=str(payload))

print r.text
static void Main(string[] args)
        {
            //Setup required variables
            string baseUrl = "https://xx-api.mimecast.com";
            string uri = "/api/ttp/remediation/find-incidents";
            string accessKey = "YOUR ACCESS KEY";
            string secretKey = "YOUR SECRET KEY";
            string appId = "YOUR APPLICATION ID";
            string appKey = "YOUR APPLICATION KEY";

            //Generate request header values
            string hdrDate = System.DateTime.Now.ToUniversalTime().ToString("R");
            string requestId = System.Guid.NewGuid().ToString();

            //Create the HMAC SHA1 of the Base64 decoded secret key for the Authorization header
            System.Security.Cryptography.HMAC h = new System.Security.Cryptography.HMACSHA1(System.Convert.FromBase64String(secretKey));

            //Use the HMAC SHA1 value to sign the hdrDate + ":" requestId + ":" + URI + ":" + appkey
            byte[] hash = h.ComputeHash(System.Text.Encoding.Default.GetBytes(hdrDate + ":" + requestId + ":" + uri + ":" + appKey));

            //Build the signature to be included in the Authorization header in your request
            string signature = "MC " + accessKey + ":" + System.Convert.ToBase64String(hash);

            //Build Request
            System.Net.HttpWebRequest request = (System.Net.HttpWebRequest)System.Net.WebRequest.Create(baseUrl + uri);
            request.Method = "POST";
            request.ContentType = "application/json";

            //Add Headers
            request.Headers[System.Net.HttpRequestHeader.Authorization] = signature;
            request.Headers.Add("x-mc-date", hdrDate);
            request.Headers.Add("x-mc-req-id", requestId);
            request.Headers.Add("x-mc-app-id", appId);

            //Add request body
            //Create and write data to stream
            string postData = @"{
                    ""data"": [
                        {
                            ""searchBy"": {
                                ""value"": ""String"",
                                ""fieldName"": ""String""
                            },
                            ""start"": ""2015-11-16T14:49:18+0000"",
                            ""end"": ""2015-11-16T14:49:18+0000"",
                            ""filterBy"": {
                                ""value"": ""String"",
                                ""fieldName"": ""String""
                            }
                        }
                    ]
                }";

            byte[] payload = System.Text.Encoding.UTF8.GetBytes(postData);

            System.IO.Stream stream = request.GetRequestStream();
            stream.Write(payload, 0, payload.Length);
            stream.Close();

            //Send Request
            System.Net.HttpWebResponse response = (System.Net.HttpWebResponse)request.GetResponse();

            //Output response to console
            System.IO.StreamReader reader = new System.IO.StreamReader(response.GetResponseStream());
            string responseBody = "";
            string temp = null;
            while ((temp = reader.ReadLine()) != null)
            {
                responseBody += temp;
            };
            System.Console.WriteLine(responseBody);
            System.Console.ReadLine();
        }
#Setup required variables
$baseUrl = "https://xx-api.mimecast.com"
$uri = "/api/ttp/remediation/find-incidents"
$url = $baseUrl + $uri
$accessKey = "YOUR ACCESS KEY"
$secretKey = "YOUR SECRET KEY"
$appId = "YOUR APPLICATION ID"
$appKey = "YOUR APPLICATION KEY"

#Generate request header values
$hdrDate = (Get-Date).ToUniversalTime().ToString("ddd, dd MMM yyyy HH:mm:ss UTC")
$requestId = [guid]::NewGuid().guid

#Create the HMAC SHA1 of the Base64 decoded secret key for the Authorization header
$sha = New-Object System.Security.Cryptography.HMACSHA1
$sha.key = [Convert]::FromBase64String($secretKey)
$sig = $sha.ComputeHash([Text.Encoding]::UTF8.GetBytes($hdrDate + ":" + $requestId + ":" + $uri + ":" + $appKey))
$sig = [Convert]::ToBase64String($sig)

#Create Headers
$headers = @{"Authorization" = "MC " + $accessKey + ":" + $sig;
                "x-mc-date" = $hdrDate;
                "x-mc-app-id" = $appId;
                "x-mc-req-id" = $requestId;
                "Content-Type" = "application/json"}

#Create post body
$postBody = "{
                    ""data"": [
                        {
                            ""searchBy"": {
                                ""value"": ""String"",
                                ""fieldName"": ""String""
                            },
                            ""start"": ""2015-11-16T14:49:18+0000"",
                            ""end"": ""2015-11-16T14:49:18+0000"",
                            ""filterBy"": {
                                ""value"": ""String"",
                                ""fieldName"": ""String""
                            }
                        }
                    ]
                }"

#Send Request
$response = Invoke-RestMethod -Method Post -Headers $headers -Body $postBody -Uri $url

#Print the response
$response
public static void main(String[] args) throws java.io.IOException, java.security.NoSuchAlgorithmException, java.security.InvalidKeyException {

        //set up variables for request
        String baseUrl = "https://xx-api.mimecast.com";
        String uri = "/api/ttp/remediation/find-incidents";
        String url = "https://" + baseUrl + uri;
        String accessKey = "YOUR ACCESS KEY";
        String secretKey = "YOUR SECRET KEY";
        String appId = "YOUR APPLICATION ID";
        String appKey = "YOUR APPLICATION KEY";

        //create URL object
        java.net.URL obj = new java.net.URL(url);

        // set guid for x-mc-req-id header
        String guid = java.util.UUID.randomUUID().toString();

        // set date for x-mc-date header
        java.text.SimpleDateFormat sdf = new java.text.SimpleDateFormat("EEE, d MMM yyyy HH:mm:ss z");
        sdf.setTimeZone(java.util.TimeZone.getTimeZone("UTC"));
        String date = sdf.format(new java.util.Date());

        //create signature for the Authorization header
        String dataToSign = date + ":" + guid + ":" + uri + ":" + appKey;
        String hmacSHA1 = "HmacSHA1";
        javax.crypto.spec.SecretKeySpec signingKey = new javax.crypto.spec.SecretKeySpec(org.apache.commons.codec.binary.Base64.decodeBase64(secretKey.getBytes()), hmacSHA1);
        javax.crypto.Mac mac = javax.crypto.Mac.getInstance(hmacSHA1);
        mac.init(signingKey);
        String sig = new String(org.apache.commons.codec.binary.Base64.encodeBase64(mac.doFinal(dataToSign.getBytes())));

        // create request object
        javax.net.ssl.HttpsURLConnection con = (javax.net.ssl.HttpsURLConnection) obj.openConnection();

        //set request type to POST
        con.setRequestMethod("POST");
        con.setDoOutput(true);

        //add reuqest headers
        con.setRequestProperty("Authorization", "MC " + accessKey + ":" + sig);
        con.setRequestProperty("x-mc-req-id", guid);
        con.setRequestProperty("x-mc-app-id", appId);
        con.setRequestProperty("x-mc-date", date);
        con.setRequestProperty("Content-Type", "application/json");
        con.setRequestProperty("Accept", "application/json");

        //Add post body to the request
        String postBody = "{\n" +
        " \"data\": [\n" +
        "     {\n" +
        "          \"searchBy\": {\n" +
        "               \"value\": \"String\"\n +
        "               \"fieldName\": \"String\"\n +
        "          }\n" +
        "          \"start\": \"2015-11-16T14:49:18+0000\"\n +
        "          \"end\": \"2015-11-16T14:49:18+0000\"\n +
        "          \"filterBy\": {\n" +
        "               \"value\": \"String\"\n +
        "               \"fieldName\": \"String\"\n +
        "          }\n" +
        "     }\n" +
        " ]\n" +
        "}";
        java.io.OutputStream os = con.getOutputStream();
        os.write(postBody.getBytes("UTF-8"));
        os.close();

        //process response
        java.io.BufferedReader in = new java.io.BufferedReader(
                new java.io.InputStreamReader(con.getInputStream()));
        String inputLine;
        StringBuffer response = new StringBuffer();

        while ((inputLine = in.readLine()) != null) {
            response.append(inputLine);
        }
        in.close();

        //return result
        java.lang.System.out.println(response.toString());
    }