pycti 6.5.6__py3-none-any.whl → 6.5.8__py3-none-any.whl

pycti/__init__.py

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-__version__ = "6.5.6"
+__version__ = "6.5.8"
 
 from .api.opencti_api_client import OpenCTIApiClient
 from .api.opencti_api_connector import OpenCTIApiConnector

pycti/api/opencti_api_client.py

@@ -751,6 +751,7 @@ class OpenCTIApiClient:
         """
 
         connector_id = kwargs.get("connector_id", None)
+        work_id = kwargs.get("work_id", None)
         bundle = kwargs.get("bundle", None)
 
         if connector_id is not None and bundle is not None:
@@ -758,13 +759,13 @@ class OpenCTIApiClient:
                 "Pushing a bundle to queue through API", {connector_id}
             )
             mutation = """
-                    mutation StixBundlePush($connectorId: String!, $bundle: String!) {
-                        stixBundlePush(connectorId: $connectorId, bundle: $bundle)
+                    mutation StixBundlePush($connectorId: String!, $bundle: String!, $work_id: String) {
+                        stixBundlePush(connectorId: $connectorId, bundle: $bundle, work_id: $work_id)
                     }
                  """
             return self.query(
                 mutation,
-                {"connectorId": connector_id, "bundle": bundle},
+                {"connectorId": connector_id, "bundle": bundle, "work_id": work_id},
             )
         else:
             self.app_logger.error(

pycti/api/opencti_api_connector.py

@@ -72,6 +72,7 @@ class OpenCTIApiConnector:
                         }
                         listen
                         listen_exchange
+                        listen_callback_uri
                         push
                         push_exchange
                         push_routing

pycti/connector/opencti_connector.py

@@ -43,6 +43,7 @@ class OpenCTIConnector:
         auto: bool,
         only_contextual: bool,
         playbook_compatible: bool,
+        listen_callback_uri=None,
     ):
         self.id = connector_id
         self.name = connector_name
@@ -56,6 +57,7 @@ class OpenCTIConnector:
         self.auto = auto
         self.only_contextual = only_contextual
         self.playbook_compatible = playbook_compatible
+        self.listen_callback_uri = listen_callback_uri
 
     def to_input(self) -> dict:
         """connector input to use in API query
@@ -72,5 +74,6 @@ class OpenCTIConnector:
                 "auto": self.auto,
                 "only_contextual": self.only_contextual,
                 "playbook_compatible": self.playbook_compatible,
+                "listen_callback_uri": self.listen_callback_uri,
             }
         }

pycti/connector/opencti_connector_helper.py

@@ -18,6 +18,9 @@ from queue import Queue
 from typing import Callable, Dict, List, Optional, Union
 
 import pika
+import uvicorn
+from fastapi import FastAPI, Request
+from fastapi.responses import JSONResponse
 from filigran_sseclient import SSEClient
 from pika.exceptions import NackError, UnroutableError
 from pydantic import TypeAdapter
@@ -30,6 +33,8 @@ from pycti.utils.opencti_stix2_splitter import OpenCTIStix2Splitter
 TRUTHY: List[str] = ["yes", "true", "True"]
 FALSY: List[str] = ["no", "false", "False"]
 
+app = FastAPI()
+
 
 def killProgramHook(etype, value, tb):
     os.kill(os.getpid(), signal.SIGTERM)
@@ -141,6 +146,35 @@ def ssl_cert_chain(ssl_context, cert_data, key_data, passphrase):
         os.unlink(key_file_path)
 
 
+def create_callback_ssl_context(config) -> ssl.SSLContext:
+    listen_protocol_api_ssl_key = get_config_variable(
+        "LISTEN_PROTOCOL_API_SSL_KEY",
+        ["connector", "listen_protocol_api_ssl_key"],
+        config,
+        default="",
+    )
+    listen_protocol_api_ssl_cert = get_config_variable(
+        "LISTEN_PROTOCOL_API_SSL_CERT",
+        ["connector", "listen_protocol_api_ssl_cert"],
+        config,
+        default="",
+    )
+    listen_protocol_api_ssl_passphrase = get_config_variable(
+        "LISTEN_PROTOCOL_API_SSL_PASSPHRASE",
+        ["connector", "listen_protocol_api_ssl_passphrase"],
+        config,
+        default="",
+    )
+    ssl_context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
+    ssl_cert_chain(
+        ssl_context,
+        listen_protocol_api_ssl_cert,
+        listen_protocol_api_ssl_key,
+        listen_protocol_api_ssl_passphrase,
+    )
+    return ssl_context
+
+
 def create_mq_ssl_context(config) -> ssl.SSLContext:
     use_ssl_ca = get_config_variable("MQ_USE_SSL_CA", ["mq", "use_ssl_ca"], config)
     use_ssl_cert = get_config_variable(
@@ -183,9 +217,14 @@ class ListenQueue(threading.Thread):
     def __init__(
         self,
         helper,
+        opencti_token,
         config: Dict,
         connector_config: Dict,
         applicant_id,
+        listen_protocol,
+        listen_protocol_api_ssl,
+        listen_protocol_api_path,
+        listen_protocol_api_port,
         callback,
     ) -> None:
         threading.Thread.__init__(self)
@@ -196,6 +235,11 @@ class ListenQueue(threading.Thread):
         self.helper = helper
         self.callback = callback
         self.config = config
+        self.opencti_token = opencti_token
+        self.listen_protocol = listen_protocol
+        self.listen_protocol_api_ssl = listen_protocol_api_ssl
+        self.listen_protocol_api_path = listen_protocol_api_path
+        self.listen_protocol_api_port = listen_protocol_api_port
         self.connector_applicant_id = applicant_id
         self.host = connector_config["connection"]["host"]
         self.vhost = connector_config["connection"]["vhost"]
@@ -375,52 +419,122 @@ class ListenQueue(threading.Thread):
                         "Failing reporting the processing"
                     )
 
+    async def _http_process_callback(self, request: Request):
+        # 01. Check the authentication
+        authorization: str = request.headers.get("Authorization", "")
+        items = authorization.split() if isinstance(authorization, str) else []
+        if (
+            len(items) != 2
+            or items[0].lower() != "bearer"
+            or items[1] != self.opencti_token
+        ):
+            return JSONResponse(
+                status_code=401, content={"error": "Invalid credentials"}
+            )
+        # 02. Parse the data and execute
+        try:
+            data = await request.json()  # Get the JSON payload
+        except json.JSONDecodeError as e:
+            self.helper.connector_logger.error(
+                "Invalid JSON payload", {"cause": str(e)}
+            )
+            return JSONResponse(
+                status_code=400,
+                content={"error": "Invalid JSON payload"},
+            )
+        try:
+            self._data_handler(data)
+        except Exception as e:
+            self.helper.connector_logger.error(
+                "Error processing message", {"cause": str(e)}
+            )
+            return JSONResponse(
+                status_code=500,
+                content={"error": "Error processing message"},
+            )
+        # all good
+        return JSONResponse(
+            status_code=202, content={"message": "Message successfully received"}
+        )
+
     def run(self) -> None:
-        self.helper.connector_logger.info("Starting ListenQueue thread")
-        while not self.exit_event.is_set():
-            try:
-                self.helper.connector_logger.info("ListenQueue connecting to rabbitMq.")
-                # Connect the broker
-                self.pika_credentials = pika.PlainCredentials(self.user, self.password)
-                self.pika_parameters = pika.ConnectionParameters(
-                    heartbeat=10,
-                    blocked_connection_timeout=30,
-                    host=self.host,
-                    port=self.port,
-                    virtual_host=self.vhost,
-                    credentials=self.pika_credentials,
-                    ssl_options=(
-                        pika.SSLOptions(create_mq_ssl_context(self.config), self.host)
-                        if self.use_ssl
-                        else None
-                    ),
-                )
-                self.pika_connection = pika.BlockingConnection(self.pika_parameters)
-                self.channel = self.pika_connection.channel()
+        if self.listen_protocol == "AMQP":
+            self.helper.connector_logger.info("Starting ListenQueue thread")
+            while not self.exit_event.is_set():
                 try:
-                    # confirm_delivery is only for cluster mode rabbitMQ
-                    # when not in cluster mode this line raise an exception
-                    self.channel.confirm_delivery()
+                    self.helper.connector_logger.info(
+                        "ListenQueue connecting to rabbitMq."
+                    )
+                    # Connect the broker
+                    self.pika_credentials = pika.PlainCredentials(
+                        self.user, self.password
+                    )
+                    self.pika_parameters = pika.ConnectionParameters(
+                        heartbeat=10,
+                        blocked_connection_timeout=30,
+                        host=self.host,
+                        port=self.port,
+                        virtual_host=self.vhost,
+                        credentials=self.pika_credentials,
+                        ssl_options=(
+                            pika.SSLOptions(
+                                create_mq_ssl_context(self.config), self.host
+                            )
+                            if self.use_ssl
+                            else None
+                        ),
+                    )
+                    self.pika_connection = pika.BlockingConnection(self.pika_parameters)
+                    self.channel = self.pika_connection.channel()
+                    try:
+                        # confirm_delivery is only for cluster mode rabbitMQ
+                        # when not in cluster mode this line raise an exception
+                        self.channel.confirm_delivery()
+                    except Exception as err:  # pylint: disable=broad-except
+                        self.helper.connector_logger.debug(str(err))
+                    self.channel.basic_qos(prefetch_count=1)
+                    assert self.channel is not None
+                    self.channel.basic_consume(
+                        queue=self.queue_name, on_message_callback=self._process_message
+                    )
+                    self.channel.start_consuming()
                 except Exception as err:  # pylint: disable=broad-except
-                    self.helper.connector_logger.debug(str(err))
-                self.channel.basic_qos(prefetch_count=1)
-                assert self.channel is not None
-                self.channel.basic_consume(
-                    queue=self.queue_name, on_message_callback=self._process_message
-                )
-                self.channel.start_consuming()
-            except Exception as err:  # pylint: disable=broad-except
-                try:
-                    self.pika_connection.close()
-                except Exception as errInException:
-                    self.helper.connector_logger.debug(
-                        type(errInException).__name__, {"reason": str(errInException)}
+                    try:
+                        self.pika_connection.close()
+                    except Exception as errInException:
+                        self.helper.connector_logger.debug(
+                            type(errInException).__name__,
+                            {"reason": str(errInException)},
+                        )
+                    self.helper.connector_logger.error(
+                        type(err).__name__, {"reason": str(err)}
                     )
-                self.helper.connector_logger.error(
-                    type(err).__name__, {"reason": str(err)}
-                )
-                # Wait some time and then retry ListenQueue again.
-                time.sleep(10)
+                    # Wait some time and then retry ListenQueue again.
+                    time.sleep(10)
+        elif self.listen_protocol == "API":
+            self.helper.connector_logger.info("Starting Listen HTTP thread")
+            app.add_api_route(
+                self.listen_protocol_api_path,
+                self._http_process_callback,
+                methods=["POST"],
+            )
+            config = uvicorn.Config(
+                app,
+                host="0.0.0.0",
+                port=self.listen_protocol_api_port,
+                reload=False,
+                log_config=None,
+                log_level=None,
+            )
+            config.load()  # Manually calling the .load() to trigger needed actions outside HTTPS
+            if self.listen_protocol_api_ssl:
+                ssl_ctx = create_callback_ssl_context(self.config)
+                config.ssl = ssl_ctx
+            server = uvicorn.Server(config)
+            server.run()
+
+        else:
+            raise ValueError("Unsupported listen protocol type")
 
     def stop(self):
         self.helper.connector_logger.info("Preparing ListenQueue for clean shutdown")
@@ -790,8 +904,39 @@ class OpenCTIConnectorHelper:  # pylint: disable=too-many-public-methods
         self.connect_id = get_config_variable(
             "CONNECTOR_ID", ["connector", "id"], config
         )
-        self.queue_protocol = get_config_variable(
-            "QUEUE_PROTOCOL", ["connector", "queue_protocol"], config, default="amqp"
+        self.listen_protocol = get_config_variable(
+            "CONNECTOR_LISTEN_PROTOCOL",
+            ["connector", "listen_protocol"],
+            config,
+            default="AMQP",
+        ).upper()
+        self.listen_protocol_api_port = get_config_variable(
+            "CONNECTOR_LISTEN_PROTOCOL_API_PORT",
+            ["connector", "listen_protocol_api_port"],
+            config,
+            default=7070,
+        )
+        self.listen_protocol_api_path = get_config_variable(
+            "CONNECTOR_LISTEN_PROTOCOL_API_PATH",
+            ["connector", "listen_protocol_api_path"],
+            config,
+            default="/api/callback",
+        )
+        self.listen_protocol_api_ssl = get_config_variable(
+            "CONNECTOR_LISTEN_PROTOCOL_API_SSL",
+            ["connector", "listen_protocol_api_ssl"],
+            config,
+            default=False,
+        )
+        self.listen_protocol_api_uri = get_config_variable(
+            "CONNECTOR_LISTEN_PROTOCOL_API_URI",
+            ["connector", "listen_protocol_api_uri"],
+            config,
+            default=(
+                "https://127.0.0.1:7070"
+                if self.listen_protocol_api_ssl
+                else "http://127.0.0.1:7070"
+            ),
         )
         self.connect_type = get_config_variable(
             "CONNECTOR_TYPE", ["connector", "type"], config
@@ -957,6 +1102,7 @@ class OpenCTIConnectorHelper:  # pylint: disable=too-many-public-methods
             self.connect_auto,
             self.connect_only_contextual,
             playbook_compatible,
+            self.listen_protocol_api_uri + self.listen_protocol_api_path,
         )
         connector_configuration = self.api.connector.register(self.connector)
         self.connector_logger.info(
@@ -972,6 +1118,25 @@ class OpenCTIConnectorHelper:  # pylint: disable=too-many-public-methods
         self.connector_state = connector_configuration["connector_state"]
         self.connector_config = connector_configuration["config"]
 
+        # Configure the push information protocol
+        self.queue_protocol = get_config_variable(
+            env_var="CONNECTOR_QUEUE_PROTOCOL",
+            yaml_path=["connector", "queue_protocol"],
+            config=config,
+        )
+        if not self.queue_protocol:  # for backwards compatibility
+            self.queue_protocol = get_config_variable(
+                env_var="QUEUE_PROTOCOL",
+                yaml_path=["connector", "queue_protocol"],
+                config=config,
+            )
+            if self.queue_protocol:
+                self.connector_logger.error(
+                    "QUEUE_PROTOCOL is deprecated, please use CONNECTOR_QUEUE_PROTOCOL instead."
+                )
+        if not self.queue_protocol:
+            self.queue_protocol = "amqp"
+
         # Overwrite connector config for RabbitMQ if given manually / in conf
         self.connector_config["connection"]["host"] = get_config_variable(
             "MQ_HOST",
@@ -1441,9 +1606,14 @@ class OpenCTIConnectorHelper:  # pylint: disable=too-many-public-methods
 
         self.listen_queue = ListenQueue(
             self,
+            self.opencti_token,
             self.config,
             self.connector_config,
             self.applicant_id,
+            self.listen_protocol,
+            self.listen_protocol_api_ssl,
+            self.listen_protocol_api_path,
+            self.listen_protocol_api_port,
             message_callback,
         )
         self.listen_queue.start()
@@ -1742,13 +1912,13 @@ class OpenCTIConnectorHelper:  # pylint: disable=too-many-public-methods
             raise ValueError("Nothing to import")
 
         if bundle_send_to_queue:
-            if work_id:
-                self.api.work.add_expectations(work_id, expectations_number)
-                if draft_id:
-                    self.api.work.add_draft_context(work_id, draft_id)
+            if work_id and draft_id:
+                self.api.work.add_draft_context(work_id, draft_id)
             if entities_types is None:
                 entities_types = []
             if self.queue_protocol == "amqp":
+                if work_id:
+                    self.api.work.add_expectations(work_id, expectations_number)
                 pika_credentials = pika.PlainCredentials(
                     self.connector_config["connection"]["user"],
                     self.connector_config["connection"]["pass"],
@@ -1791,7 +1961,7 @@ class OpenCTIConnectorHelper:  # pylint: disable=too-many-public-methods
                 pika_connection.close()
             elif self.queue_protocol == "api":
                 self.api.send_bundle_to_api(
-                    connector_id=self.connector_id, bundle=bundle
+                    connector_id=self.connector_id, bundle=bundle, work_id=work_id
                 )
             else:
                 raise ValueError(

pycti/entities/opencti_threat_actor.py

@@ -178,6 +178,7 @@ class ThreatActor:
         order_by = kwargs.get("orderBy", None)
         order_mode = kwargs.get("orderMode", None)
         custom_attributes = kwargs.get("customAttributes", None)
+        get_all = kwargs.get("getAll", False)
         with_pagination = kwargs.get("withPagination", False)
 
         self.opencti.app_logger.info(
@@ -216,9 +217,31 @@ class ThreatActor:
                 "orderMode": order_mode,
             },
         )
-        return self.opencti.process_multiple(
-            result["data"]["threatActors"], with_pagination
-        )
+        if get_all:
+            final_data = []
+            data = self.opencti.process_multiple(result["data"]["threatActors"])
+            final_data = final_data + data
+            while result["data"]["threatActors"]["pageInfo"]["hasNextPage"]:
+                after = result["data"]["threatActors"]["pageInfo"]["endCursor"]
+                self.opencti.app_logger.info("Listing threatActors", {"after": after})
+                result = self.opencti.query(
+                    query,
+                    {
+                        "filters": filters,
+                        "search": search,
+                        "first": first,
+                        "after": after,
+                        "orderBy": order_by,
+                        "orderMode": order_mode,
+                    },
+                )
+                data = self.opencti.process_multiple(result["data"]["threatActors"])
+                final_data = final_data + data
+            return final_data
+        else:
+            return self.opencti.process_multiple(
+                result["data"]["threatActors"], with_pagination
+            )
 
     def read(self, **kwargs) -> Union[dict, None]:
         """Read a Threat-Actor object

pycti/entities/opencti_threat_actor_group.py

@@ -171,6 +171,7 @@ class ThreatActorGroup:
         order_by = kwargs.get("orderBy", None)
         order_mode = kwargs.get("orderMode", None)
         custom_attributes = kwargs.get("customAttributes", None)
+        get_all = kwargs.get("getAll", False)
         with_pagination = kwargs.get("withPagination", False)
 
         self.opencti.app_logger.info(
@@ -209,9 +210,35 @@ class ThreatActorGroup:
                 "orderMode": order_mode,
             },
         )
-        return self.opencti.process_multiple(
-            result["data"]["threatActorsGroup"], with_pagination
-        )
+        if get_all:
+            final_data = []
+            data = self.opencti.process_multiple(result["data"]["threatActorsGroup"])
+            final_data = final_data + data
+            while result["data"]["threatActorsGroup"]["pageInfo"]["hasNextPage"]:
+                after = result["data"]["threatActorsGroup"]["pageInfo"]["endCursor"]
+                self.opencti.app_logger.info(
+                    "Listing threatActorsGroup", {"after": after}
+                )
+                result = self.opencti.query(
+                    query,
+                    {
+                        "filters": filters,
+                        "search": search,
+                        "first": first,
+                        "after": after,
+                        "orderBy": order_by,
+                        "orderMode": order_mode,
+                    },
+                )
+                data = self.opencti.process_multiple(
+                    result["data"]["threatActorsGroup"]
+                )
+                final_data = final_data + data
+            return final_data
+        else:
+            return self.opencti.process_multiple(
+                result["data"]["threatActorsGroup"], with_pagination
+            )
 
     def read(self, **kwargs) -> Union[dict, None]:
         """Read a Threat-Actor-Group object

pycti/entities/opencti_threat_actor_individual.py

@@ -171,6 +171,7 @@ class ThreatActorIndividual:
         order_by = kwargs.get("orderBy", None)
         order_mode = kwargs.get("orderMode", None)
         custom_attributes = kwargs.get("customAttributes", None)
+        get_all = kwargs.get("getAll", False)
         with_pagination = kwargs.get("withPagination", False)
 
         self.opencti.app_logger.info(
@@ -210,9 +211,39 @@ class ThreatActorIndividual:
                 "orderMode": order_mode,
             },
         )
-        return self.opencti.process_multiple(
-            result["data"]["threatActorsIndividuals"], with_pagination
-        )
+        if get_all:
+            final_data = []
+            data = self.opencti.process_multiple(
+                result["data"]["threatActorsIndividuals"]
+            )
+            final_data = final_data + data
+            while result["data"]["threatActorsIndividuals"]["pageInfo"]["hasNextPage"]:
+                after = result["data"]["threatActorsIndividuals"]["pageInfo"][
+                    "endCursor"
+                ]
+                self.opencti.app_logger.info(
+                    "Listing threatActorsIndividuals", {"after": after}
+                )
+                result = self.opencti.query(
+                    query,
+                    {
+                        "filters": filters,
+                        "search": search,
+                        "first": first,
+                        "after": after,
+                        "orderBy": order_by,
+                        "orderMode": order_mode,
+                    },
+                )
+                data = self.opencti.process_multiple(
+                    result["data"]["threatActorsIndividuals"]
+                )
+                final_data = final_data + data
+            return final_data
+        else:
+            return self.opencti.process_multiple(
+                result["data"]["threatActorsIndividuals"], with_pagination
+            )
 
     def read(self, **kwargs) -> Union[dict, None]:
         """Read a Threat-Actor-Individual object

{pycti-6.5.6.dist-info → pycti-6.5.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: pycti
-Version: 6.5.6
+Version: 6.5.8
 Summary: Python API client for OpenCTI.
 Home-page: https://github.com/OpenCTI-Platform/client-python
 Author: Filigran
@@ -28,13 +28,15 @@ Requires-Dist: python-magic~=0.4.27; sys_platform == "linux" or sys_platform ==
 Requires-Dist: python-magic-bin~=0.4.14; sys_platform == "win32"
 Requires-Dist: python_json_logger~=2.0.4
 Requires-Dist: PyYAML~=6.0
-Requires-Dist: requests~=2.32.2
+Requires-Dist: requests<=2.32.3,>=2.32.0
 Requires-Dist: setuptools~=71.1.0
 Requires-Dist: cachetools~=5.5.0
 Requires-Dist: prometheus-client~=0.21.1
 Requires-Dist: opentelemetry-api<=1.30.0,>=1.22.0
 Requires-Dist: opentelemetry-sdk<=1.30.0,>=1.22.0
 Requires-Dist: deprecation~=2.1.0
+Requires-Dist: fastapi<0.116.0,>=0.115.8
+Requires-Dist: uvicorn[standard]<0.35.0,>=0.33.0
 Requires-Dist: filigran-sseclient>=1.0.2
 Requires-Dist: stix2~=3.0.1
 Provides-Extra: dev

{pycti-6.5.6.dist-info → pycti-6.5.8.dist-info}/RECORD

@@ -1,12 +1,12 @@
-pycti/__init__.py,sha256=8Qm7LDreYXpxsLc-IqTQcRdPomwsSoWCyd22fTZSa_s,5218
+pycti/__init__.py,sha256=Jx64e7EmY0sso4XUf7Z80mh3mf64-Jmv6goncnzLrSM,5218
 pycti/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pycti/api/opencti_api_client.py,sha256=6TKvtgAk0iYQL2RaLTUV6cxCBefEgwmlL_iVHgzf_ow,32745
-pycti/api/opencti_api_connector.py,sha256=ubM_zPjTD8L33TEugCQgf_YF9zugDFg_7FgNubGlwJw,5447
+pycti/api/opencti_api_client.py,sha256=l-k8UclU4-yyc0rn_N3CZcRDiHUmD4-boOnQ6mngCO8,32848
+pycti/api/opencti_api_connector.py,sha256=ZCatDnkwqGvNwtagd3f3MziG4nuplGj7BEw8xSXh47o,5491
 pycti/api/opencti_api_playbook.py,sha256=456We78vESukfSOi_CctfZ9dbBJEi76EHClRc2f21Js,1628
 pycti/api/opencti_api_work.py,sha256=qIRJMCfyC9odXf7LMRg9ImYizqF2WHUOU7Ty5IUFGg8,8351
 pycti/connector/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pycti/connector/opencti_connector.py,sha256=5oVvS27KWhzRiofJAeQPDtba-EP83FziSistyEd5l-U,2561
-pycti/connector/opencti_connector_helper.py,sha256=ee8Ej43Ox9W7G44PEfHNGZuU_NmBVNl7dE3V3BzE4sE,81286
+pycti/connector/opencti_connector.py,sha256=8lCZFvcA9-S1x6vFl756hgWAlzKfrnq-C4AIdDJr-Kg,2715
+pycti/connector/opencti_connector_helper.py,sha256=r8xu5frk0zD0HUBn5xG9aXH1H5QvpydXsC7fUzq_85k,87688
 pycti/connector/opencti_metric_handler.py,sha256=4jXHeJflomtHjuQ_YU0b36TG7o26vOWbY_jvU8Ezobs,3725
 pycti/entities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pycti/entities/opencti_attack_pattern.py,sha256=QXJaMMZlnVCxxHGZNGSKPLmHL3TgM08aUIS8SypmIek,22193
@@ -48,9 +48,9 @@ pycti/entities/opencti_stix_nested_ref_relationship.py,sha256=7USJlfTanPFY16aFIH
 pycti/entities/opencti_stix_object_or_stix_relationship.py,sha256=5qutzML6SyYzDhZ-QpI9Vh23hzLEs-xeFAAZOpGHZ2g,18049
 pycti/entities/opencti_stix_sighting_relationship.py,sha256=PO4RK3UBkA2b_xcqjiqWnLSKgvaQy291al_yunQ96h4,28736
 pycti/entities/opencti_task.py,sha256=rYfiUKtsSEq8A-Qa2wi7QBias1oiiHsaq3g_aLcWgl0,25290
-pycti/entities/opencti_threat_actor.py,sha256=Fk33LU8lsCP0SMMaA0SkT7fLZLmjddMi_-9PUJToDuM,10156
-pycti/entities/opencti_threat_actor_group.py,sha256=DuLT4DlAEtS7yQVbkFcAbPcyWsrdwYX5XBevsVuprxY,19515
-pycti/entities/opencti_threat_actor_individual.py,sha256=IhfsRBXvR73fwUQ5JYZ2GsRHuzVb92l6JaKvaqTdKp0,19767
+pycti/entities/opencti_threat_actor.py,sha256=vFPeo0pOYSqHBKVlWc4o8RjuP2PP0A09KWU6rsYXnvA,11201
+pycti/entities/opencti_threat_actor_group.py,sha256=ANvs1C_ugpYv_jNwW9mOwn4jXKTmkV7tL5wdPgt3PXA,20661
+pycti/entities/opencti_threat_actor_individual.py,sha256=i41YIdC7Mc5qMzdYmzItI1qVdDqngqsA1kMWGngRDGo,21011
 pycti/entities/opencti_tool.py,sha256=YbOp0Ur5Do7ToLzfIKGX-MtlBQf-Dt9Qtgk1lI9Q7aU,15295
 pycti/entities/opencti_vocabulary.py,sha256=xupdHJ6TznCmvI3sVYU261SnfblSNc1nwg19MG9yrao,6499
 pycti/entities/opencti_vulnerability.py,sha256=ssMH7EB7WC--Nv2bq-D-_wLBGXMgP3ZLK-X8SslpVJQ,22614
@@ -67,8 +67,8 @@ pycti/utils/opencti_stix2_identifier.py,sha256=k8L1z4q1xdCBfxqUba4YS_kT-MmbJFxYh
 pycti/utils/opencti_stix2_splitter.py,sha256=etnAWMDzNi2JCovSUJ5Td-XLVdzgKRdsV1XfpXOGols,11070
 pycti/utils/opencti_stix2_update.py,sha256=CnMyqkeVA0jgyxEcgqna8sABU4YPMjkEJ228GVurIn4,14658
 pycti/utils/opencti_stix2_utils.py,sha256=xgBZzm7HC76rLQYwTKkaUd_w9jJnVMoryHx7KDDIB_g,5065
-pycti-6.5.6.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-pycti-6.5.6.dist-info/METADATA,sha256=0Glf-tGlglFdyp3ZHGThkKn0koXL6ORGbnGAws8Ixdg,5443
-pycti-6.5.6.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
-pycti-6.5.6.dist-info/top_level.txt,sha256=cqEpxitAhHP4VgSA6xmrak6Yk9MeBkwoMTB6k7d2ZnE,6
-pycti-6.5.6.dist-info/RECORD,,
+pycti-6.5.8.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+pycti-6.5.8.dist-info/METADATA,sha256=jKpN0aP7v8pSiR0pew5dv3jnb8C3JB9CPh6tf2qLn7g,5542
+pycti-6.5.8.dist-info/WHEEL,sha256=beeZ86-EfXScwlR_HKu4SllMC9wUEj_8Z_4FJ3egI2w,91
+pycti-6.5.8.dist-info/top_level.txt,sha256=cqEpxitAhHP4VgSA6xmrak6Yk9MeBkwoMTB6k7d2ZnE,6
+pycti-6.5.8.dist-info/RECORD,,

{pycti-6.5.6.dist-info → pycti-6.5.8.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (76.0.0)
+Generator: setuptools (76.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any