feat(forcepoint-dlp): new Forcepoint DLP integration

Forcepoint DLP REST API v1, 4 commands: list incidents, get incident, update
incident (status/severity/assignee). Token auth, stdlib-only.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

integrations/forcepoint-dlp/manifest.yaml

@@ -0,0 +1,70 @@
+id: forcepoint_dlp
+name: Forcepoint DLP
+version: 1.0.0
+description: "Forcepoint DLP (Security Manager REST API v1) — data-loss-prevention incident handling: list incidents in a time window, read an incident, and update incident status/severity/assignment. Token authentication; stdlib-only, no extra Python dependencies."
+changelog: "1.0.0 — Initial release: list incidents, get incident, update incident."
+category: dlp
+
+# Per-instance configuration. Credentials are exchanged for an access token
+# (Bearer) used on the DLP REST API.
+config_schema:
+  properties:
+    base_url:
+      type: string
+      description: "Forcepoint Security Manager URL (e.g. https://fsm.example.com:9443)"
+    username:
+      type: string
+      description: "API username"
+    password:
+      type: string
+      description: "API password"
+      x-soar-sensitive: true
+    insecure:
+      type: boolean
+      description: "Trust any TLS certificate (not secure)"
+      default: false
+  required:
+    - base_url
+    - username
+    - password
+
+commands:
+  - id: list_incidents
+    name: forcepoint-list-incidents
+    description: "List DLP incidents in a time window."
+    risk: read
+    inputs_schema:
+      properties:
+        from_date: { type: string, description: "Start date (YYYY-MM-DDTHH:MM:SS)" }
+        to_date: { type: string, description: "End date (YYYY-MM-DDTHH:MM:SS)" }
+        action: { type: string, description: "Optional action filter (e.g. Blocked, Permitted)" }
+      required: [from_date, to_date]
+    outputs_schema: { properties: {} }
+  - id: get_incident
+    name: forcepoint-get-incident
+    description: "Get a single DLP incident by ID."
+    risk: read
+    inputs_schema:
+      properties:
+        incident_id: { type: string, description: "Incident ID" }
+      required: [incident_id]
+    outputs_schema: { properties: {} }
+  - id: update_incident
+    name: forcepoint-update-incident
+    description: "Update DLP incidents (status, severity, or assignee)."
+    inputs_schema:
+      properties:
+        incident_ids: { type: string, description: "Comma-separated incident IDs" }
+        action_type: { type: string, description: "Field to update: STATUS, SEVERITY, or ASSIGNED_TO" }
+        value: { type: string, description: "New value for the field" }
+      required: [incident_ids, action_type, value]
+    outputs_schema: { properties: {} }
+
+  - id: test_connection
+    name: forcepoint-test-connection
+    description: "Verify connectivity and credentials (used by the Test button)."
+    risk: read
+    inputs_schema:
+      properties: {}
+      required: []
+    outputs_schema: { properties: {} }

integrations/forcepoint-dlp/scripts/get_incident.py

@@ -0,0 +1,77 @@
+import json, os, sys, ssl, urllib.parse, urllib.request, urllib.error
+
+
+def _cfg():
+    return json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+
+
+def _inputs():
+    return json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+
+
+def _ctx(cfg):
+    if cfg.get("insecure"):
+        c = ssl.create_default_context()
+        c.check_hostname = False
+        c.verify_mode = ssl.CERT_NONE
+        return c
+    return None
+
+
+def _base(cfg):
+    return str(cfg.get("base_url", "")).rstrip("/") + "/dlp/rest/v1"
+
+
+def _token(cfg):
+    body = json.dumps({"username": cfg.get("username", ""), "password": cfg.get("password", "")}).encode("utf-8")
+    req = urllib.request.Request(_base(cfg) + "/auth/refresh-token", data=body,
+                                 headers={"Content-Type": "application/json", "Accept": "application/json"}, method="POST")
+    with urllib.request.urlopen(req, timeout=60, context=_ctx(cfg)) as r:
+        tok = json.loads(r.read())
+    at = tok.get("access_token") or tok.get("accessToken")
+    if not at:
+        raise Exception("Auth failed: " + json.dumps(tok))
+    return at
+
+
+def request(method, path, cfg, token, body=None, params=None):
+    url = _base(cfg) + path
+    if params:
+        clean = {k: v for k, v in params.items() if v not in (None, "")}
+        if clean:
+            url += "?" + urllib.parse.urlencode(clean)
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    headers = {"Authorization": "Bearer " + token, "Accept": "application/json"}
+    if data is not None:
+        headers["Content-Type"] = "application/json"
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=90, context=_ctx(cfg)) as r:
+        raw = r.read()
+        return json.loads(raw) if raw else {}
+
+
+def _run(fn):
+    try:
+        cfg = _cfg()
+        inputs = _inputs()
+        token = _token(cfg)
+        print(json.dumps(fn(cfg, token, inputs)))
+    except urllib.error.HTTPError as e:
+        print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+        sys.exit(1)
+    except Exception as e:
+        print(json.dumps({"error": str(e)}))
+        sys.exit(1)
+
+
+def main(cfg, token, inputs):
+    incident_id = inputs.get("incident_id")
+    if not incident_id:
+        raise Exception("incident_id is required")
+
+    q = lambda v: urllib.parse.quote(str(v), safe="")
+
+    return request("GET", "/incidents/" + q(incident_id), cfg, token)
+
+
+_run(main)

integrations/forcepoint-dlp/scripts/list_incidents.py

@@ -0,0 +1,84 @@
+import json, os, sys, ssl, urllib.parse, urllib.request, urllib.error
+
+
+def _cfg():
+    return json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+
+
+def _inputs():
+    return json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+
+
+def _ctx(cfg):
+    if cfg.get("insecure"):
+        c = ssl.create_default_context()
+        c.check_hostname = False
+        c.verify_mode = ssl.CERT_NONE
+        return c
+    return None
+
+
+def _base(cfg):
+    return str(cfg.get("base_url", "")).rstrip("/") + "/dlp/rest/v1"
+
+
+def _token(cfg):
+    body = json.dumps({"username": cfg.get("username", ""), "password": cfg.get("password", "")}).encode("utf-8")
+    req = urllib.request.Request(_base(cfg) + "/auth/refresh-token", data=body,
+                                 headers={"Content-Type": "application/json", "Accept": "application/json"}, method="POST")
+    with urllib.request.urlopen(req, timeout=60, context=_ctx(cfg)) as r:
+        tok = json.loads(r.read())
+    at = tok.get("access_token") or tok.get("accessToken")
+    if not at:
+        raise Exception("Auth failed: " + json.dumps(tok))
+    return at
+
+
+def request(method, path, cfg, token, body=None, params=None):
+    url = _base(cfg) + path
+    if params:
+        clean = {k: v for k, v in params.items() if v not in (None, "")}
+        if clean:
+            url += "?" + urllib.parse.urlencode(clean)
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    headers = {"Authorization": "Bearer " + token, "Accept": "application/json"}
+    if data is not None:
+        headers["Content-Type"] = "application/json"
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=90, context=_ctx(cfg)) as r:
+        raw = r.read()
+        return json.loads(raw) if raw else {}
+
+
+def _run(fn):
+    try:
+        cfg = _cfg()
+        inputs = _inputs()
+        token = _token(cfg)
+        print(json.dumps(fn(cfg, token, inputs)))
+    except urllib.error.HTTPError as e:
+        print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+        sys.exit(1)
+    except Exception as e:
+        print(json.dumps({"error": str(e)}))
+        sys.exit(1)
+
+
+def main(cfg, token, inputs):
+    from_date = inputs.get("from_date")
+    to_date = inputs.get("to_date")
+    if not from_date:
+        raise Exception("from_date is required")
+    if not to_date:
+        raise Exception("to_date is required")
+
+    body = {"type": "INCIDENTS", "from_date": from_date, "to_date": to_date}
+
+    action = inputs.get("action")
+    if action:
+        body["action"] = [action]
+
+    return request("POST", "/incidents", cfg, token, body=body)
+
+
+_run(main)

integrations/forcepoint-dlp/scripts/test_connection.py

@@ -0,0 +1,71 @@
+import json, os, sys, ssl, urllib.parse, urllib.request, urllib.error
+
+
+def _cfg():
+    return json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+
+
+def _inputs():
+    return json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+
+
+def _ctx(cfg):
+    if cfg.get("insecure"):
+        c = ssl.create_default_context()
+        c.check_hostname = False
+        c.verify_mode = ssl.CERT_NONE
+        return c
+    return None
+
+
+def _base(cfg):
+    return str(cfg.get("base_url", "")).rstrip("/") + "/dlp/rest/v1"
+
+
+def _token(cfg):
+    body = json.dumps({"username": cfg.get("username", ""), "password": cfg.get("password", "")}).encode("utf-8")
+    req = urllib.request.Request(_base(cfg) + "/auth/refresh-token", data=body,
+                                 headers={"Content-Type": "application/json", "Accept": "application/json"}, method="POST")
+    with urllib.request.urlopen(req, timeout=60, context=_ctx(cfg)) as r:
+        tok = json.loads(r.read())
+    at = tok.get("access_token") or tok.get("accessToken")
+    if not at:
+        raise Exception("Auth failed: " + json.dumps(tok))
+    return at
+
+
+def request(method, path, cfg, token, body=None, params=None):
+    url = _base(cfg) + path
+    if params:
+        clean = {k: v for k, v in params.items() if v not in (None, "")}
+        if clean:
+            url += "?" + urllib.parse.urlencode(clean)
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    headers = {"Authorization": "Bearer " + token, "Accept": "application/json"}
+    if data is not None:
+        headers["Content-Type"] = "application/json"
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=90, context=_ctx(cfg)) as r:
+        raw = r.read()
+        return json.loads(raw) if raw else {}
+
+
+def _run(fn):
+    try:
+        cfg = _cfg()
+        inputs = _inputs()
+        token = _token(cfg)
+        print(json.dumps(fn(cfg, token, inputs)))
+    except urllib.error.HTTPError as e:
+        print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+        sys.exit(1)
+    except Exception as e:
+        print(json.dumps({"error": str(e)}))
+        sys.exit(1)
+
+
+def main(cfg, token, inputs):
+    return {"ok": True}
+
+
+_run(main)

integrations/forcepoint-dlp/scripts/update_incident.py

@@ -0,0 +1,91 @@
+import json, os, sys, ssl, urllib.parse, urllib.request, urllib.error
+
+
+def _cfg():
+    return json.loads(os.environ.get("INTEGRATION_SECRETS", "{}"))
+
+
+def _inputs():
+    return json.loads(os.environ.get("INTEGRATION_INPUTS", "{}"))
+
+
+def _ctx(cfg):
+    if cfg.get("insecure"):
+        c = ssl.create_default_context()
+        c.check_hostname = False
+        c.verify_mode = ssl.CERT_NONE
+        return c
+    return None
+
+
+def _base(cfg):
+    return str(cfg.get("base_url", "")).rstrip("/") + "/dlp/rest/v1"
+
+
+def _token(cfg):
+    body = json.dumps({"username": cfg.get("username", ""), "password": cfg.get("password", "")}).encode("utf-8")
+    req = urllib.request.Request(_base(cfg) + "/auth/refresh-token", data=body,
+                                 headers={"Content-Type": "application/json", "Accept": "application/json"}, method="POST")
+    with urllib.request.urlopen(req, timeout=60, context=_ctx(cfg)) as r:
+        tok = json.loads(r.read())
+    at = tok.get("access_token") or tok.get("accessToken")
+    if not at:
+        raise Exception("Auth failed: " + json.dumps(tok))
+    return at
+
+
+def request(method, path, cfg, token, body=None, params=None):
+    url = _base(cfg) + path
+    if params:
+        clean = {k: v for k, v in params.items() if v not in (None, "")}
+        if clean:
+            url += "?" + urllib.parse.urlencode(clean)
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    headers = {"Authorization": "Bearer " + token, "Accept": "application/json"}
+    if data is not None:
+        headers["Content-Type"] = "application/json"
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    with urllib.request.urlopen(req, timeout=90, context=_ctx(cfg)) as r:
+        raw = r.read()
+        return json.loads(raw) if raw else {}
+
+
+def _run(fn):
+    try:
+        cfg = _cfg()
+        inputs = _inputs()
+        token = _token(cfg)
+        print(json.dumps(fn(cfg, token, inputs)))
+    except urllib.error.HTTPError as e:
+        print(json.dumps({"error": "HTTP " + str(e.code), "detail": e.read().decode("utf-8", "replace")}))
+        sys.exit(1)
+    except Exception as e:
+        print(json.dumps({"error": str(e)}))
+        sys.exit(1)
+
+
+def main(cfg, token, inputs):
+    incident_ids = inputs.get("incident_ids")
+    action_type = inputs.get("action_type")
+    value = inputs.get("value")
+
+    if not incident_ids:
+        raise Exception("incident_ids is required")
+    if not action_type:
+        raise Exception("action_type is required")
+    if not value:
+        raise Exception("value is required")
+
+    incident_ids_list = [s.strip() for s in str(incident_ids).split(",") if s.strip()]
+
+    body = {
+        "incidents": [int(x) if x.isdigit() else x for x in incident_ids_list],
+        "action_type": action_type,
+        "value": value,
+    }
+
+    result = request("PATCH", "/incidents", cfg, token, body=body)
+    return {"ok": True} if not result else result
+
+
+_run(main)