Get image profiles from secure (#96)

Author: flaviomutti-sysdig

examples/list_profiles.py

@@ -0,0 +1,47 @@
+#!/usr/bin/env python
+#
+# List the current set of image profiles.
+#
+
+import os
+import sys
+import json
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.realpath(sys.argv[0])), '..'))
+from sdcclient import SdSecureClient
+
+
+def usage():
+    print('usage: %s <secure-endpoint> <sysdig-token>' % sys.argv[0])
+    sys.exit(1)
+
+
+#
+# Check number of parameters
+#
+if len(sys.argv) < 2:
+    usage()
+
+sdc_endpoint = sys.argv[1]
+sdc_token   = sys.argv[2]
+
+#
+# Instantiate the SDC client
+#
+sdclient = SdSecureClient(sdc_token, sdc_endpoint)
+
+#
+# Retrieve all the image profiles
+#
+ok, res = sdclient.list_image_profiles()
+
+
+if not ok:
+    print(res)
+    sys.exit(1)
+
+
+# Strip the surrounding json to only keep the list of profiles
+res = res['profiles']
+
+for profile in res:
+    print("ID: {}, Name: {}".format(profile["profileId"], profile["imageName"]))

sdcclient/_secure.py

@@ -974,3 +974,181 @@ def get_command_audit(self, id, metrics=[]):
             metrics="&metrics=" + json.dumps(metrics) if metrics else "")
         res = requests.get(url, headers=self.hdrs, verify=self.ssl_verify)
         return self._request_result(res)
+
+    def list_image_profiles(self):
+        '''**Description**
+            List the current set of image profiles.
+
+        **Arguments**
+            - None
+
+        **Success Return Value**
+            A JSON object containing the details of each profile.
+
+        '''
+        url = "{url}/api/profiling/v1/secure/profileGroups/0/profiles".format(
+            url = self.url
+        )
+
+        res = requests.get(url, headers=self.hdrs, verify=self.ssl_verify)
+        return self._request_result(res)
+
+
+    def get_image_profile(self, profileId):
+        '''**Description**
+            Find the image profile with a (partial) profile ID <profileId> and return its json description.
+
+        **Arguments**
+            - name: the name of the image profile to fetch
+
+        **Success Return Value**
+            A JSON object containing the description of the image profile. If there is no image profile with
+            the given name, returns False. Moreover, it could happen that more than one profile IDs have a collision.
+            It is due to the fact that a partial profile ID can be passed and interpreted; in this case a set of
+            collision profiles is returned, and the full complete ID string is printed. In this case, it returns
+            false.
+
+        '''
+
+        # RETRIEVE ALL THE IMAGE PROFILES
+        ok, image_profiles = self.list_image_profiles()
+
+        if not ok:
+            return [False, self.lasterr]
+
+        
+        '''
+        The content of the json stored in the image_profiles dictionary:
+
+        {
+            "offset": 0,
+            "limit": 99,
+            "canLoadMore": false,
+            "profiles": [
+            ...
+            ]
+        }
+        '''
+        
+        matched_profiles = self.__get_matched_profileIDs(profileId, image_profiles['profiles'])
+        
+        # Profile ID not found
+        if len(matched_profiles) == 0:
+            return [False, "No profile with ID {}".format(profileId)]
+        
+        # Principal workflow. Profile ID found
+        elif len(matched_profiles) == 1:
+            # Matched id. Return information
+            url = "{url}/api/profiling/v1/secure/profiles/{profileId}".format(
+                url = self.url,
+                profileId = matched_profiles[0]['profileId']
+            )
+            
+            res = requests.get(url, headers=self.hdrs, verify=self.ssl_verify)
+            return self._request_result(res)
+
+        # Collision detected. The full profile IDs are returned
+        elif len(matched_profiles) >= 2:
+            return [False, matched_profiles]
+
+
+    def __get_matched_profileIDs(self, requested_profile, profile_list):
+        '''
+        **Description**
+            Helper function for  retrieving the list of matching profile
+        
+        **Arguments**
+            - the requested profile Id (string)
+            - List of dictionary, where each dictionary contains the profile information
+    
+        **Success Return Value**
+            List of dictionary, where each dictionary represents a profile with the ID prefix substring
+            matching the requested one
+        
+        **Content structure of the profile_list parameter**
+        This array of profiles contains all the relevant information. For the purposes of this function, only
+        the profileId field is relevant.
+        
+        [
+            {
+            "profileGroupId": 0,
+            "profileId": "00000000000000000000000000000000000000000000",
+            "profileVersion": 0,
+            "profileName": "AAA/BBB:XYZ@0000000000000000000000",
+            "imageId": "00000000000000000000000000000000000000000000",
+            "imageName": "AAA/BBB:XYZ",
+            "processesProposal": {
+                "subcategories": [
+                                    {
+                                    "name": "process",
+                                    "ruleName": "process - 00000000000000000000000000000000000000000000",
+                                    "ruleType": "PROCESS",
+                                    "score": 000
+                                    }
+                                ],
+                                "score": 000
+            },
+            "fileSystemProposal": {
+                "subcategories": [
+                                    {
+                                    "name": "filesystem",
+                                    "ruleName": "filesystem - 00000000000000000000000000000000000000000000",
+                                    "ruleType": "FILESYSTEM",
+                                    "score": 000
+                                    }
+                                ],
+                                "score": 000
+            },
+            "syscallProposal": {
+                "subcategories": [
+                                    {
+                                    "name": "syscalls",
+                                    "ruleName": "syscalls - 00000000000000000000000000000000000000000000",
+                                    "ruleType": "SYSCALL",
+                                    "score": 000
+                                    }
+                                ],
+                                "score": 000
+            },
+            "networkProposal": {
+                "subcategories": [
+                                    {
+                                    "name": "network",
+                                    "ruleName": "network - 00000000000000000000000000000000000000000000",
+                                    "ruleType": "NETWORK",
+                                    "score": 000
+                                    }
+                                ],
+                                "score": 000
+            },
+            "containerImagesProposal": {
+                "subcategories": [
+                                    {
+                                    "name": "container image",
+                                    "ruleName": "container image - 00000000000000000000000000000000000000000000",
+                                    "ruleType": "CONTAINER",
+                                    "score": 0
+                                    }
+                                ],
+                                "score": 0
+            },
+            "status": "STATUS_VALUE",
+            "score": 000
+            },
+            ...
+        ]
+        '''
+
+        matched_profiles = []
+
+        request_len = len(requested_profile)
+        for profile in profile_list:
+
+            # get the length of the substring to match    
+            str_len_match = min(len(profile), request_len)
+
+            if profile['profileId'][0:str_len_match] == requested_profile[0:str_len_match]:
+                matched_profiles.append(profile)
+
+        return matched_profiles
+