assemblyline-core 4.5.0.dev5__tar.gz → 4.5.0.dev7__tar.gz

{assemblyline-core-4.5.0.dev5 → assemblyline-core-4.5.0.dev7}/PKG-INFO

@@ -1,13 +1,12 @@
 Metadata-Version: 2.1
 Name: assemblyline-core
-Version: 4.5.0.dev5
+Version: 4.5.0.dev7
 Summary: Assemblyline 4 - Core components
 Home-page: https://github.com/CybercentreCanada/assemblyline-core/
 Author: CCCS Assemblyline development team
 Author-email: assemblyline@cyber.gc.ca
 License: MIT
 Keywords: assemblyline automated malware analysis gc canada cse-cst cse cst cyber cccs
-Platform: UNKNOWN
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Topic :: Software Development :: Libraries
@@ -59,5 +58,3 @@ Make sure the different services get their latest update files.
 ##### Workflow
 
 Run the different workflows in the system and apply their labels, priority and status.
-
-

assemblyline-core-4.5.0.dev7/assemblyline_core/VERSION

@@ -0,0 +1 @@
+4.5.0.dev7

{assemblyline-core-4.5.0.dev5 → assemblyline-core-4.5.0.dev7}/assemblyline_core/badlist_client.py

@@ -5,6 +5,9 @@ from assemblyline.common import forge
 from assemblyline.common.chunk import chunk
 from assemblyline.common.isotime import now_as_iso
 from assemblyline.datastore.helper import AssemblylineDatastore
+from assemblyline.odm.models.user import ROLES
+from assemblyline.remote.datatypes.lock import Lock
+
 
 CHUNK_SIZE = 1000
 CLASSIFICATION = forge.get_classification()
@@ -14,6 +17,7 @@ class InvalidBadhash(Exception):
     pass
 
 
+# Badlist class
 class BadlistClient:
     """A helper class to simplify badlisting for privileged services and service-server."""
 
@@ -22,7 +26,115 @@ class BadlistClient:
         self.config = config or forge.CachedObject(forge.get_config)
         self.datastore = datastore or forge.get_datastore(self.config)
 
-    # Badlist
+    def _preprocess_object(self, data: dict) -> str:
+        # Set defaults
+        data.setdefault('classification', CLASSIFICATION.UNRESTRICTED)
+        data.setdefault('hashes', {})
+        data.setdefault('expiry_ts', None)
+        if data['type'] == 'tag':
+            # Remove file related fields
+            data.pop('file', None)
+            data.pop('hashes', None)
+
+            tag_data = data.get('tag', None)
+            if tag_data is None or 'type' not in tag_data or 'value' not in tag_data:
+                raise ValueError("Tag data not found")
+
+            hashed_value = f"{tag_data['type']}: {tag_data['value']}".encode('utf8')
+            data['hashes'] = {
+                'md5': hashlib.md5(hashed_value).hexdigest(),
+                'sha1': hashlib.sha1(hashed_value).hexdigest(),
+                'sha256': hashlib.sha256(hashed_value).hexdigest()
+            }
+
+        elif data['type'] == 'file':
+            data.pop('tag', None)
+            data.setdefault('file', {})
+
+        # Ensure expiry_ts is set on tag-related items
+        dtl = data.pop('dtl', None) or self.config.core.expiry.badlisted_tag_dtl * 24 * 3600
+        if dtl:
+            data['expiry_ts'] = now_as_iso(dtl)
+
+        # Set last updated
+        data['added'] = data['updated'] = now_as_iso()
+
+        # Find the best hash to use for the key
+        for hash_key in ['sha256', 'sha1', 'md5']:
+            qhash = data['hashes'].get(hash_key, None)
+            if qhash:
+                break
+
+        # Validate hash length
+        if not qhash:
+            raise ValueError("No valid hash found")
+
+        return qhash
+
+    def add_update(self, badlist_object: dict, user: dict = None):
+        qhash = self._preprocess_object(badlist_object)
+
+        # Validate sources
+        src_map = {}
+        for src in badlist_object['sources']:
+            if user:
+                if src['type'] == 'user':
+                    if src['name'] != user['uname']:
+                        raise ValueError(f"You cannot add a source for another user. {src['name']} != {user['uname']}")
+                else:
+                    if ROLES.signature_import not in user['roles']:
+                        raise PermissionError("You do not have sufficient priviledges to add an external source.")
+
+            # Find the highest classification of all sources
+            badlist_object['classification'] = CLASSIFICATION.max_classification(
+                badlist_object['classification'], src.get('classification', None))
+
+            src_map[src['name']] = src
+
+        with Lock(f'add_or_update-badlist-{qhash}', 30):
+            old = self.datastore.badlist.get_if_exists(qhash, as_obj=False)
+            if old:
+                # Save data to the DB
+                self.datastore.badlist.save(qhash, BadlistClient._merge_hashes(badlist_object, old))
+                return qhash, "update"
+            else:
+                try:
+                    badlist_object['sources'] = list(src_map.values())
+                    self.datastore.badlist.save(qhash, badlist_object)
+                    return qhash, "add"
+                except Exception as e:
+                    return ValueError(f"Invalid data provided: {str(e)}")
+
+    def add_update_many(self, list_of_badlist_objects: list):
+        if not isinstance(list_of_badlist_objects, list):
+            raise ValueError("Could not get the list of hashes")
+
+        new_data = {}
+        for badlist_object in list_of_badlist_objects:
+            qhash = self._preprocess_object(badlist_object)
+            new_data[qhash] = badlist_object
+
+        # Get already existing hashes
+        old_data = self.datastore.badlist.multiget(list(new_data.keys()), as_dictionary=True, as_obj=False,
+                                                   error_on_missing=False)
+
+        # Test signature names
+        plan = self.datastore.badlist.get_bulk_plan()
+        for key, val in new_data.items():
+            # Use maximum classification
+            old_val = old_data.get(key, {'classification': CLASSIFICATION.UNRESTRICTED, 'attribution': {},
+                                         'hashes': {}, 'sources': [], 'type': val['type']})
+
+            # Add upsert operation
+            plan.add_upsert_operation(key, BadlistClient._merge_hashes(val, old_val))
+
+        if not plan.empty:
+            # Execute plan
+            res = self.datastore.badlist.bulk(plan)
+            return {"success": len(res['items']), "errors": res['errors']}
+
+        return {"success": 0, "errors": []}
+
     def exists(self, qhash):
         return self.datastore.badlist.get_if_exists(qhash, as_obj=False)
 

{assemblyline-core-4.5.0.dev5 → assemblyline-core-4.5.0.dev7}/assemblyline_core/safelist_client.py

@@ -1,10 +1,12 @@
+import hashlib
 import logging
-
 import yaml
 
 from assemblyline.common import forge
 from assemblyline.common.isotime import now_as_iso
 from assemblyline.datastore.helper import AssemblylineDatastore
+from assemblyline.odm.models.user import ROLES
+from assemblyline.remote.datatypes.lock import Lock
 
 CLASSIFICATION = forge.get_classification()
 
@@ -13,7 +15,7 @@ class InvalidSafehash(Exception):
     pass
 
 
-# Tasking class
+# Safelist class
 class SafelistClient:
     """A helper class to simplify safelisting for privileged services and service-server."""
 
@@ -22,7 +24,134 @@ class SafelistClient:
         self.config = config or forge.CachedObject(forge.get_config)
         self.datastore = datastore or forge.get_datastore(self.config)
 
-    # Safelist
+    def _preprocess_object(self, data: dict):
+        # Set defaults
+        data.setdefault('classification', CLASSIFICATION.UNRESTRICTED)
+        data.setdefault('hashes', {})
+        data.setdefault('expiry_ts', None)
+        if data['type'] == 'tag':
+            # Remove file related fields
+            data.pop('file', None)
+            data.pop('hashes', None)
+            data.pop('signature', None)
+
+            tag_data = data.get('tag', None)
+            if tag_data is None or 'type' not in tag_data or 'value' not in tag_data:
+                raise ValueError("Tag data not found")
+
+            hashed_value = f"{tag_data['type']}: {tag_data['value']}".encode('utf8')
+            data['hashes'] = {
+                'md5': hashlib.md5(hashed_value).hexdigest(),
+                'sha1': hashlib.sha1(hashed_value).hexdigest(),
+                'sha256': hashlib.sha256(hashed_value).hexdigest()
+            }
+
+        elif data['type'] == 'signature':
+            # Remove file related fields
+            data.pop('file', None)
+            data.pop('hashes', None)
+            data.pop('tag', None)
+
+            sig_data = data.get('signature', None)
+            if sig_data is None or 'name' not in sig_data:
+                raise ValueError("Signature data not found")
+
+            hashed_value = f"signature: {sig_data['name']}".encode('utf8')
+            data['hashes'] = {
+                'md5': hashlib.md5(hashed_value).hexdigest(),
+                'sha1': hashlib.sha1(hashed_value).hexdigest(),
+                'sha256': hashlib.sha256(hashed_value).hexdigest()
+            }
+
+        elif data['type'] == 'file':
+            data.pop('signature', None)
+            data.pop('tag', None)
+            data.setdefault('file', {})
+
+        # Ensure expiry_ts is set on tag-related items
+        dtl = data.pop('dtl', None) or self.config.core.expiry.safelisted_tag_dtl * 24 * 3600
+        if dtl:
+            data['expiry_ts'] = now_as_iso(dtl)
+
+        # Set last updated
+        data['added'] = data['updated'] = now_as_iso()
+
+        # Find the best hash to use for the key
+        for hash_key in ['sha256', 'sha1', 'md5']:
+            qhash = data['hashes'].get(hash_key, None)
+            if qhash:
+                break
+
+        # Validate hash length
+        if not qhash:
+            raise ValueError("No valid hash found")
+
+        return qhash
+
+    def add_update(self, safelist_object: dict, user: dict = None):
+        qhash = self._preprocess_object(safelist_object)
+
+        # Validate sources
+        src_map = {}
+        for src in safelist_object['sources']:
+            if user:
+                if src['type'] == 'user':
+                    if src['name'] != user['uname']:
+                        raise ValueError(f"You cannot add a source for another user. {src['name']} != {user['uname']}")
+                else:
+                    if ROLES.signature_import not in user['roles']:
+                        raise PermissionError("You do not have sufficient priviledges to add an external source.")
+
+            # Find the highest classification of all sources
+            safelist_object['classification'] = CLASSIFICATION.max_classification(
+                safelist_object['classification'], src.get('classification', None))
+
+            src_map[src['name']] = src
+
+        with Lock(f'add_or_update-safelist-{qhash}', 30):
+            old = self.datastore.safelist.get_if_exists(qhash, as_obj=False)
+            if old:
+                # Save data to the DB
+                self.datastore.safelist.save(qhash, SafelistClient._merge_hashes(safelist_object, old))
+                return qhash, "update"
+            else:
+                try:
+                    safelist_object['sources'] = list(src_map.values())
+                    self.datastore.safelist.save(qhash, safelist_object)
+                    return qhash, "add"
+                except Exception as e:
+                    return ValueError(f"Invalid data provided: {str(e)}")
+
+    def add_update_many(self, list_of_safelist_objects: list):
+        if not isinstance(list_of_safelist_objects, list):
+            raise ValueError("Could not get the list of hashes")
+
+        new_data = {}
+        for safelist_object in list_of_safelist_objects:
+            qhash = self._preprocess_object(safelist_object)
+            new_data[qhash] = safelist_object
+
+        # Get already existing hashes
+        old_data = self.datastore.safelist.multiget(list(new_data.keys()), as_dictionary=True, as_obj=False,
+                                                    error_on_missing=False)
+
+        # Test signature names
+        plan = self.datastore.safelist.get_bulk_plan()
+        for key, val in new_data.items():
+            # Use maximum classification
+            old_val = old_data.get(key, {'classification': CLASSIFICATION.UNRESTRICTED,
+                                         'hashes': {}, 'sources': [], 'type': val['type']})
+
+            # Add upsert operation
+            plan.add_upsert_operation(key, SafelistClient._merge_hashes(val, old_val))
+
+        if not plan.empty:
+            # Execute plan
+            res = self.datastore.safelist.bulk(plan)
+            return {"success": len(res['items']), "errors": res['errors']}
+
+        return {"success": 0, "errors": []}
+
     def exists(self, qhash):
         return self.datastore.safelist.get_if_exists(qhash, as_obj=False)
 

{assemblyline-core-4.5.0.dev5 → assemblyline-core-4.5.0.dev7}/assemblyline_core/scaler/scaler_server.py

@@ -71,7 +71,6 @@ DOCKER_CONFIGURATION_PATH = os.getenv('DOCKER_CONFIGURATION_PATH', None)
 DOCKER_CONFIGURATION_VOLUME = os.getenv('DOCKER_CONFIGURATION_VOLUME', None)
 
 SERVICE_API_HOST = os.getenv('SERVICE_API_HOST', None)
-UI_SERVER = os.getenv('UI_SERVER', None)
 INTERNAL_ENCRYPT = bool(SERVICE_API_HOST and SERVICE_API_HOST.startswith('https'))
 SERVICE_PREFIX = 'alsvc-'
 
@@ -274,7 +273,7 @@ class ScalerServer(ThreadedCoreBase):
         core_env: dict[str, str] = {}
         # If we have privileged services, we must be able to pass the necessary environment variables for them to
         # function properly.
-        for secret in re.findall(r'\${\w+}', open('/etc/assemblyline/config.yml', 'r').read()) + ['UI_SERVER']:
+        for secret in re.findall(r'\${\w+}', open('/etc/assemblyline/config.yml', 'r').read()):
             env_name = secret.strip("${}")
             try:
                 core_env[env_name] = os.environ[env_name]

assemblyline-core-4.5.0.dev7/assemblyline_core/signature_client.py

@@ -0,0 +1,210 @@
+import logging
+
+from assemblyline.common import forge
+from assemblyline.common.isotime import iso_to_epoch, now_as_iso
+from assemblyline.common.memory_zip import InMemoryZip
+from assemblyline.datastore.helper import AssemblylineDatastore
+from assemblyline.odm.messages.changes import Operation
+from assemblyline.odm.models.service import SIGNATURE_DELIMITERS
+from assemblyline.odm.models.signature import DEPLOYED_STATUSES, STALE_STATUSES, DRAFT_STATUSES
+
+
+DEFAULT_DELIMITER = "\n\n"
+CLASSIFICATION = forge.get_classification()
+
+
+# Signature class
+class SignatureClient:
+    """A helper class to simplify signature management for privileged services and service-server."""
+
+    def __init__(self, datastore: AssemblylineDatastore = None, config=None):
+        self.log = logging.getLogger('assemblyline.signature_client')
+        self.config = config or forge.CachedObject(forge.get_config)
+        self.datastore = datastore or forge.get_datastore(self.config)
+        self.service_list = forge.CachedObject(self.datastore.list_all_services, kwargs=dict(as_obj=False, full=True))
+        self.delimiters = forge.CachedObject(self._get_signature_delimiters)
+
+    def _get_signature_delimiters(self):
+        signature_delimiters = {}
+        for service in self.service_list:
+            if service.get("update_config", {}).get("generates_signatures", False):
+                signature_delimiters[service['name'].lower()] = self._get_signature_delimiter(service['update_config'])
+        return signature_delimiters
+
+    def _get_signature_delimiter(self, update_config):
+        delimiter_type = update_config['signature_delimiter']
+        if delimiter_type == 'custom':
+            delimiter = update_config['custom_delimiter'].encode().decode('unicode-escape')
+        else:
+            delimiter = SIGNATURE_DELIMITERS.get(delimiter_type, '\n\n')
+        return {'type': delimiter_type, 'delimiter': delimiter}
+
+    def add_update(self, data, dedup_name=True):
+        if data.get('type', None) is None or data['name'] is None or data['data'] is None:
+            raise ValueError("Signature id, name, type and data are mandatory fields.")
+
+        # Compute signature ID if missing
+        data['signature_id'] = data.get('signature_id', data['name'])
+
+        key = f"{data['type']}_{data['source']}_{data['signature_id']}"
+
+        # Test signature name
+        if dedup_name:
+            check_name_query = f"name:\"{data['name']}\" " \
+                f"AND type:\"{data['type']}\" " \
+                f"AND source:\"{data['source']}\" " \
+                f"AND NOT id:\"{key}\""
+            other = self.datastore.signature.search(check_name_query, fl='id', rows='0')
+            if other['total'] > 0:
+                raise ValueError("A signature with that name already exists")
+
+        old = self.datastore.signature.get(key, as_obj=False)
+        op = Operation.Modified if old else Operation.Added
+        if old:
+            if old['data'] == data['data']:
+                return True, key, None
+
+            # Ensure that the last state change, if any, was made by a user and not a system account.
+            user_modified_last_state = old['state_change_user'] not in ['update_service_account', None]
+
+            # If rule state is moving to an active state but was disabled by a user before:
+            # Keep original inactive state, a user changed the state for a reason
+            if user_modified_last_state and data['status'] == 'DEPLOYED' and data['status'] != old['status']:
+                data['status'] = old['status']
+
+            # Preserve last state change
+            data['state_change_date'] = old['state_change_date']
+            data['state_change_user'] = old['state_change_user']
+
+            # Preserve signature stats
+            data['stats'] = old['stats']
+
+        # Save the signature
+        success = self.datastore.signature.save(key, data)
+        return success, key, op
+
+    def add_update_many(self, source, sig_type, data, dedup_name=True):
+        if source is None or sig_type is None or not isinstance(data, list):
+            raise ValueError("Source, source type and data are mandatory fields.")
+
+        # Test signature names
+        names_map = {x['name']: f"{x['type']}_{x['source']}_{x.get('signature_id', x['name'])}" for x in data}
+
+        skip_list = []
+        if dedup_name:
+            for item in self.datastore.signature.stream_search(f"type: \"{sig_type}\" AND source:\"{source}\"",
+                                                               fl="id,name", as_obj=False, item_buffer_size=1000):
+                lookup_id = names_map.get(item['name'], None)
+                if lookup_id and lookup_id != item['id']:
+                    skip_list.append(lookup_id)
+
+            if skip_list:
+                data = [
+                    x for x in data
+                    if f"{x['type']}_{x['source']}_{x.get('signature_id', x['name'])}" not in skip_list]
+
+        old_data = self.datastore.signature.multiget(list(names_map.values()), as_dictionary=True, as_obj=False,
+                                                     error_on_missing=False)
+
+        plan = self.datastore.signature.get_bulk_plan()
+        for rule in data:
+            key = f"{rule['type']}_{rule['source']}_{rule.get('signature_id', rule['name'])}"
+            if key in old_data:
+                # Ensure that the last state change, if any, was made by a user and not a system account.
+                user_modified_last_state = old_data[key]['state_change_user'] not in ['update_service_account', None]
+
+                # If rule state is moving to an active state but was disabled by a user before:
+                # Keep original inactive state, a user changed the state for a reason
+                if user_modified_last_state and rule['status'] == 'DEPLOYED' and rule['status'] != old_data[key][
+                        'status']:
+                    rule['status'] = old_data[key]['status']
+
+                # Preserve last state change
+                rule['state_change_date'] = old_data[key]['state_change_date']
+                rule['state_change_user'] = old_data[key]['state_change_user']
+
+                # Preserve signature stats
+                rule['stats'] = old_data[key]['stats']
+
+            plan.add_upsert_operation(key, rule)
+
+        if not plan.empty:
+            res = self.datastore.signature.bulk(plan)
+            return {"success": len(res['items']), "errors": res['errors'], "skipped": skip_list}
+
+        return {"success": 0, "errors": [], "skipped": skip_list}
+
+    def change_status(self, signature_id, status, user={}):
+        possible_statuses = DEPLOYED_STATUSES + DRAFT_STATUSES
+        if status not in possible_statuses:
+            raise ValueError(f"You cannot apply the status {status} on yara rules.")
+
+        data = self.datastore.signature.get(signature_id, as_obj=False)
+        if data:
+            if user and not CLASSIFICATION.is_accessible(user['classification'],
+                                                         data.get('classification', CLASSIFICATION.UNRESTRICTED)):
+                raise PermissionError("You are not allowed change status on this signature")
+
+            if data['status'] in STALE_STATUSES and status not in DRAFT_STATUSES:
+                raise ValueError(f"Only action available while signature in {data['status']} "
+                                 f"status is to change signature to a DRAFT status. ({', '.join(DRAFT_STATUSES)})")
+
+            if data['status'] in DEPLOYED_STATUSES and status in DRAFT_STATUSES:
+                raise ValueError(f"You cannot change the status of signature {signature_id} from "
+                                 f"{data['status']} to {status}.")
+
+            today = now_as_iso()
+            uname = user.get('uname')
+
+            if status not in ['DISABLED', 'INVALID', 'TESTING']:
+                query = f"status:{status} AND signature_id:{data['signature_id']} AND NOT id:{signature_id}"
+                others_operations = [
+                    ('SET', 'last_modified', today),
+                    ('SET', 'state_change_date', today),
+                    ('SET', 'state_change_user', uname),
+                    ('SET', 'status', 'DISABLED')
+                ]
+                self.datastore.signature.update_by_query(query, others_operations)
+
+            operations = [
+                ('SET', 'last_modified', today),
+                ('SET', 'state_change_date', today),
+                ('SET', 'state_change_user', uname),
+                ('SET', 'status', status)
+            ]
+
+            return self.datastore.signature.update(signature_id, operations), data
+        raise FileNotFoundError(f"Signature not found. ({signature_id})")
+
+    def download(self, query=None, access=None) -> bytes:
+        if not query:
+            query = "*"
+
+        output_files = {}
+
+        signature_list = sorted(
+            self.datastore.signature.stream_search(
+                query, fl="signature_id,type,source,data,order", access_control=access, as_obj=False,
+                item_buffer_size=1000),
+            key=lambda x: x['order'])
+
+        for sig in signature_list:
+            out_fname = f"{sig['type']}/{sig['source']}"
+            if self.delimiters.get(sig['type'], {}).get('type', None) == 'file':
+                out_fname = f"{out_fname}/{sig['signature_id']}"
+            output_files.setdefault(out_fname, [])
+            output_files[out_fname].append(sig['data'])
+
+        output_zip = InMemoryZip()
+        for fname, data in output_files.items():
+            separator = self.delimiters.get(fname.split('/')[0], {}).get('delimiter', DEFAULT_DELIMITER)
+            output_zip.append(fname, separator.join(data))
+
+        return output_zip.read()
+
+    def update_available(self, since='', sig_type='*'):
+        since = since or '1970-01-01T00:00:00.000000Z'
+        last_update = iso_to_epoch(since)
+        last_modified = iso_to_epoch(self.datastore.get_signature_last_modified(sig_type))
+
+        return last_modified > last_update

{assemblyline-core-4.5.0.dev5 → assemblyline-core-4.5.0.dev7}/assemblyline_core/updater/run_updater.py

@@ -39,14 +39,13 @@ NAMESPACE = os.getenv('NAMESPACE', None)
 INHERITED_VARIABLES: list[str] = ['HTTP_PROXY', 'HTTPS_PROXY', 'NO_PROXY', 'http_proxy', 'https_proxy', 'no_proxy'] + \
     [
     secret.strip("${}")
-    for secret in re.findall(r'\${\w+}', open('/etc/assemblyline/config.yml', 'r').read()) + ['UI_SERVER']]
+    for secret in re.findall(r'\${\w+}', open('/etc/assemblyline/config.yml', 'r').read())]
 
 CONFIGURATION_HOST_PATH = os.getenv('CONFIGURATION_HOST_PATH', 'service_config')
 CONFIGURATION_CONFIGMAP = os.getenv('KUBERNETES_AL_CONFIG', None)
 AL_CORE_NETWORK = os.environ.get("AL_CORE_NETWORK", 'core')
 
 SERVICE_API_HOST = os.getenv('SERVICE_API_HOST')
-UI_SERVER = os.getenv('UI_SERVER')
 RELEASE_NAME = os.getenv('RELEASE_NAME')
 
 

{assemblyline-core-4.5.0.dev5 → assemblyline-core-4.5.0.dev7}/assemblyline_core.egg-info/PKG-INFO

@@ -1,13 +1,12 @@
 Metadata-Version: 2.1
 Name: assemblyline-core
-Version: 4.5.0.dev5
+Version: 4.5.0.dev7
 Summary: Assemblyline 4 - Core components
 Home-page: https://github.com/CybercentreCanada/assemblyline-core/
 Author: CCCS Assemblyline development team
 Author-email: assemblyline@cyber.gc.ca
 License: MIT
 Keywords: assemblyline automated malware analysis gc canada cse-cst cse cst cyber cccs
-Platform: UNKNOWN
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Topic :: Software Development :: Libraries
@@ -59,5 +58,3 @@ Make sure the different services get their latest update files.
 ##### Workflow
 
 Run the different workflows in the system and apply their labels, priority and status.
-
-

{assemblyline-core-4.5.0.dev5 → assemblyline-core-4.5.0.dev7}/assemblyline_core.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ assemblyline_core/__init__.py
 assemblyline_core/badlist_client.py
 assemblyline_core/safelist_client.py
 assemblyline_core/server_base.py
+assemblyline_core/signature_client.py
 assemblyline_core/submission_client.py
 assemblyline_core/tasking_client.py
 assemblyline_core.egg-info/PKG-INFO
@@ -70,12 +71,15 @@ assemblyline_core/vacuum/worker.py
 assemblyline_core/workflow/__init__.py
 assemblyline_core/workflow/run_workflow.py
 test/test_alerter.py
+test/test_badlist_client.py
 test/test_dispatcher.py
 test/test_expiry.py
 test/test_plumber.py
 test/test_replay.py
+test/test_safelist_client.py
 test/test_scaler.py
 test/test_scheduler.py
+test/test_signature_client.py
 test/test_simulation.py
 test/test_vacuum.py
 test/test_worker_ingest.py