scanoss 1.12.2__py3-none-any.whl → 1.43.1__py3-none-any.whl

scanoss/cryptography.py

@@ -0,0 +1,308 @@
+import json
+from dataclasses import dataclass
+from typing import Dict, List, Optional
+
+from scanoss.cyclonedx import CycloneDx
+from scanoss.scanossbase import ScanossBase
+from scanoss.scanossgrpc import ScanossGrpc
+from scanoss.utils.abstract_presenter import AbstractPresenter
+from scanoss.utils.file import validate_json_file
+
+
+class ScanossCryptographyError(Exception):
+    pass
+
+
+MIN_SPLIT_PARTS = 2
+
+
+@dataclass
+class CryptographyConfig:
+    purl: List[str]
+    debug: bool = False
+    header: Optional[str] = None
+    input_file: Optional[str] = None
+    output_file: Optional[str] = None
+    quiet: bool = False
+    trace: bool = False
+    use_grpc: bool = False
+    with_range: bool = False
+
+    def _process_input_file(self) -> dict:
+        """
+        Process and validate the input file, returning the validated purl_request.
+        
+        Returns:
+            dict: The validated purl_request dictionary
+            
+        Raises:
+            ScanossCryptographyError: If the input file is invalid
+        """
+        result = validate_json_file(self.input_file)
+        if not result.is_valid:
+            raise ScanossCryptographyError(
+                f'There was a problem with the purl input file. {result.error}'
+            )
+            
+        cdx = CycloneDx(debug=self.debug)
+        if cdx.is_cyclonedx_json(json.dumps(result.data)):
+            purl_request = cdx.get_purls_request_from_cdx(result.data)
+        else:
+            purl_request = result.data
+        
+        if (
+            not isinstance(purl_request, dict)
+            or 'purls' not in purl_request
+            or not isinstance(purl_request['purls'], list)
+            or not all(isinstance(p, dict) and 'purl' in p for p in purl_request['purls'])
+        ):
+            raise ScanossCryptographyError('The supplied input file is not in the correct PurlRequest format.')
+            
+        return purl_request
+
+    def __post_init__(self):
+        """
+        Validate that the configuration is valid.
+        """
+        if self.purl:
+            if self.with_range:
+                for purl in self.purl:
+                    parts = purl.split('@')
+                    if not (len(parts) >= MIN_SPLIT_PARTS and parts[1]):
+                        raise ScanossCryptographyError(
+                            f'Invalid PURL format: "{purl}".It must include a version (e.g., pkg:type/name@version)'
+                        )
+        if self.input_file:
+            purl_request = self._process_input_file()
+            purls = purl_request['purls']
+            purls_with_requirement = []
+            if self.with_range and any('requirement' not in p for p in purls):
+                raise ScanossCryptographyError(
+                    f'One or more PURLs in "{self.input_file}" are missing the "requirement" field.'
+                )
+
+            for purl in purls:
+                if 'requirement' in purl:
+                    purls_with_requirement.append(f'{purl["purl"]}@{purl["requirement"]}')
+                else:
+                    purls_with_requirement.append(purl['purl'])
+            self.purl = purls_with_requirement
+
+
+def create_cryptography_config_from_args(args) -> CryptographyConfig:
+    return CryptographyConfig(
+        debug=getattr(args, 'debug', False),
+        header=getattr(args, 'header', None),
+        input_file=getattr(args, 'input', None),
+        output_file=getattr(args, 'output', None),
+        purl=getattr(args, 'purl', []),
+        quiet=getattr(args, 'quiet', False),
+        trace=getattr(args, 'trace', False),
+        use_grpc=getattr(args, 'grpc', False),
+        with_range=getattr(args, 'with_range', False),
+    )
+
+
+class Cryptography:
+    """
+    Cryptography Class
+
+    This class is used to decorate purls with cryptography information.
+    """
+
+    def __init__(
+        self,
+        config: CryptographyConfig,
+        client: ScanossGrpc,
+    ):
+        """
+        Initialize the Cryptography.
+
+        Args:
+            config (CryptographyConfig): Configuration parameters for the cryptography.
+            client (ScanossGrpc): gRPC client for communicating with the scanning service.
+        """
+        self.base = ScanossBase(
+            debug=config.debug,
+            trace=config.trace,
+            quiet=config.quiet,
+        )
+        self.presenter = CryptographyPresenter(
+            self,
+            debug=config.debug,
+            trace=config.trace,
+            quiet=config.quiet,
+        )
+
+        self.client = client
+        self.config = config
+        self.components_request = self._build_components_request()
+        self.results = None
+
+    def get_algorithms(self) -> Optional[Dict]:
+        """
+        Get the cryptographic algorithms for the provided purl or input file.
+
+        Returns:
+            Optional[Dict]: The folder hash response from the gRPC client, or None if an error occurs.
+        """
+
+        if not self.components_request or not self.components_request.get('components'):
+            raise ScanossCryptographyError('No PURLs supplied. Provide --purl or --input.')
+        components_str = ', '.join(p['purl'] for p in self.components_request['components'])
+        self.base.print_stderr(f'Getting cryptographic algorithms for {components_str}')
+        if self.config.with_range:
+            response = self.client.get_crypto_algorithms_in_range_for_purl(
+                self.components_request, self.config.use_grpc
+            )
+        else:
+            response = self.client.get_crypto_algorithms_for_purl(self.components_request, self.config.use_grpc)
+        if response:
+            self.results = response
+
+        return self.results
+
+    def get_encryption_hints(self) -> Optional[Dict]:
+        """
+        Get the encryption hints for the provided purl or input file.
+
+        Returns:
+            Optional[Dict]: The encryption hints response from the gRPC client, or None if an error occurs.
+        """
+
+        if not self.components_request or not self.components_request.get('components'):
+            raise ScanossCryptographyError('No PURLs supplied. Provide --purl or --input.')
+        self.base.print_stderr(
+            f'Getting encryption hints '
+            f'{"in range" if self.config.with_range else ""} '
+            f'for {", ".join([p["purl"] for p in self.components_request["components"]])}'
+        )
+        if self.config.with_range:
+            response = self.client.get_encryption_hints_in_range_for_purl(self.components_request, self.config.use_grpc)
+        else:
+            response = self.client.get_encryption_hints_for_purl(self.components_request, self.config.use_grpc)
+        if response:
+            self.results = response
+
+        return self.results
+
+    def get_versions_in_range(self) -> Optional[Dict]:
+        """
+        Given a list of PURLS and version ranges, get a list of versions that do/do not contain cryptographic algorithms
+
+        Returns:
+            Optional[Dict]: The versions in range response from the gRPC client, or None if an error occurs.
+        """
+
+        if not self.components_request or not self.components_request.get('components'):
+            raise ScanossCryptographyError('No PURLs supplied. Provide --purl or --input.')
+
+        components_str = ', '.join(p['purl'] for p in self.components_request['components'])
+        self.base.print_stderr(f'Getting versions in range for {components_str}')
+
+        response = self.client.get_versions_in_range_for_purl(self.components_request, self.config.use_grpc)
+        if response:
+            self.results = response
+
+        return self.results
+
+    def _build_components_request(
+        self,
+    ) -> Optional[dict]:
+        """
+        Load the specified purls from a JSON file or a list of PURLs and return a dictionary
+
+        Returns:
+            Optional[dict]: The dictionary containing the PURLs
+        """
+        return {
+            'components': [
+                {
+                    'purl': self._remove_version_from_purl(purl),
+                    'requirement': self._extract_version_from_purl(purl),
+                }
+                for purl in self.config.purl
+            ]
+        }
+
+    def _remove_version_from_purl(self, purl: str) -> str:
+        """
+        Remove version from purl
+
+        Args:
+            purl (str): The purl string to remove the version from
+
+        Returns:
+            str: The purl string without the version
+        """
+        if '@' not in purl:
+            return purl
+        return purl.split('@')[0]
+
+    def _extract_version_from_purl(self, purl: str) -> str:
+        """
+        Extract version from purl
+
+        Args:
+            purl (str): The purl string to extract the version from
+
+        Returns:
+            str: The extracted version
+
+        Raises:
+            ScanossCryptographyError: If the purl is not in the correct format
+        """
+        try:
+            return purl.split('@')[-1]
+        except IndexError:
+            raise ScanossCryptographyError(f'Invalid purl format: {purl}')
+
+    def present(
+        self,
+        output_format: Optional[str] = None,
+        output_file: Optional[str] = None,
+    ):
+        """Present the results in the selected format"""
+        self.presenter.present(output_format=output_format, output_file=output_file)
+
+
+class CryptographyPresenter(AbstractPresenter):
+    """
+    Cryptography presenter class
+    Handles the presentation of the cryptography results
+    """
+
+    def __init__(self, cryptography: Cryptography, **kwargs):
+        super().__init__(**kwargs)
+        self.cryptography = cryptography
+
+    def _format_json_output(self) -> str:
+        """
+        Format the scan output data into a JSON object
+
+        Returns:
+            str: The formatted JSON string
+        """
+        return json.dumps(self.cryptography.results, indent=2)
+
+    def _format_plain_output(self) -> str:
+        """
+        Format the scan output data into a plain text string
+        """
+        return (
+            json.dumps(self.cryptography.results, indent=2)
+            if isinstance(self.cryptography.results, dict)
+            else str(self.cryptography.results)
+        )
+
+    def _format_cyclonedx_output(self) -> str:
+        raise NotImplementedError('CycloneDX output is not implemented')
+
+    def _format_spdxlite_output(self) -> str:
+        raise NotImplementedError('SPDXlite output is not implemented')
+
+    def _format_csv_output(self) -> str:
+        raise NotImplementedError('CSV output is not implemented')
+
+    def _format_raw_output(self) -> str:
+        raise NotImplementedError('Raw output is not implemented')

scanoss/csvoutput.py

@@ -1,30 +1,30 @@
 """
- SPDX-License-Identifier: MIT
+SPDX-License-Identifier: MIT
 
-   Copyright (c) 2022, SCANOSS
+  Copyright (c) 2022, SCANOSS
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
 
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
+  The above copyright notice and this permission notice shall be included in
+  all copies or substantial portions of the Software.
 
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+  THE SOFTWARE.
 """
+import csv
 import json
 import os.path
 import sys
-import csv
 
 from .scanossbase import ScanossBase
 
@@ -43,37 +43,41 @@ class CsvOutput(ScanossBase):
         self.output_file = output_file
         self.debug = debug
 
-    def parse(self, data: json):
+    # TODO Refactor (fails linter)
+    def parse(self, data: json): #noqa PLR0912, PLR0915
         """
         Parse the given input (raw/plain) JSON string and return CSV summary
         :param data: json - JSON object
         :return: CSV dictionary
         """
-        if not data:
+        if data is None:
             self.print_stderr('ERROR: No JSON data provided to parse.')
             return None
-        self.print_debug(f'Processing raw results into CSV format...')
+        if len(data) == 0:
+            self.print_msg('Warning: Empty scan results provided. Returning empty CSV list.')
+            return []
+        self.print_debug('Processing raw results into CSV format...')
         csv_dict = []
         row_id = 1
         for f in data:
             file_details = data.get(f)
             # print(f'File: {f}: {file_details}')
             for d in file_details:
-                id_details = d.get("id")
+                id_details = d.get('id')
                 if not id_details or id_details == 'none':
                     continue
-                matched = d.get("matched", '')
-                lines = d.get("lines", '').replace(',', ';')  # swap comma with semicolon to help basic parsers
-                oss_lines = d.get("oss_lines", '').replace(',', ';')
+                matched = d.get('matched', '')
+                lines = d.get('lines', '').replace(',', ';')  # swap comma with semicolon to help basic parsers
+                oss_lines = d.get('oss_lines', '').replace(',', ';')
                 detected = {}
                 if id_details == 'dependency':
-                    dependencies = d.get("dependencies")
+                    dependencies = d.get('dependencies')
                     if not dependencies:
                         self.print_stderr(f'Warning: No Dependencies found for {f}: {file_details}')
                         continue
                     for deps in dependencies:
                         detected = {}
-                        purl = deps.get("purl")
+                        purl = deps.get('purl')
                         if not purl:
                             self.print_stderr(f'Warning: No PURL found for {f}: {deps}')
                             continue
@@ -84,25 +88,32 @@ class CsvOutput(ScanossBase):
                         dc = []
                         if licenses:
                             for lic in licenses:
-                                name = lic.get("name")
+                                name = lic.get('name')
                                 if name and name not in dc:  # Only save the license name once
                                     dc.append(name)
                         if not dc or len(dc) == 0:
                             detected['licenses'] = ''
                         else:
                             detected['licenses'] = ';'.join(dc)
-                        # inventory_id,path,usage,detected_component,detected_license,detected_version,detected_latest,purl
-                        csv_dict.append({'inventory_id': row_id, 'path': f, 'detected_usage': id_details,
-                                         'detected_component': detected.get('component'),
-                                         'detected_license': detected.get('licenses'),
-                                         'detected_version': detected.get('version'),
-                                         'detected_latest': detected.get('latest'),
-                                         'detected_purls': detected.get('purls'),
-                                         'detected_url': detected.get('url'),
-                                         'detected_path': detected.get('file', ''),
-                                         'detected_match': matched, 'detected_lines': lines,
-                                         'detected_oss_lines': oss_lines
-                                         })
+                        # inventory_id,path,usage,detected_component,detected_license,
+                        # detected_version,detected_latest,purl
+                        csv_dict.append(
+                            {
+                                'inventory_id': row_id,
+                                'path': f,
+                                'detected_usage': id_details,
+                                'detected_component': detected.get('component'),
+                                'detected_license': detected.get('licenses'),
+                                'detected_version': detected.get('version'),
+                                'detected_latest': detected.get('latest'),
+                                'detected_purls': detected.get('purls'),
+                                'detected_url': detected.get('url'),
+                                'detected_path': detected.get('file', ''),
+                                'detected_match': matched,
+                                'detected_lines': lines,
+                                'detected_oss_lines': oss_lines,
+                            }
+                        )
                         row_id = row_id + 1
                 else:
                     purls = d.get('purl')
@@ -123,25 +134,31 @@ class CsvOutput(ScanossBase):
                     dc = []
                     if licenses:
                         for lic in licenses:
-                            name = lic.get("name")
+                            name = lic.get('name')
                             if name and name not in dc:  # Only save the license name once
-                                dc.append(lic.get("name"))
+                                dc.append(lic.get('name'))
                     if not dc or len(dc) == 0:
                         detected['licenses'] = ''
                     else:
                         detected['licenses'] = ';'.join(dc)
                     # inventory_id,path,usage,detected_component,detected_license,detected_version,detected_latest,purl
-                    csv_dict.append({'inventory_id': row_id, 'path': f, 'detected_usage': id_details,
-                                     'detected_component': detected.get('component'),
-                                     'detected_license': detected.get('licenses'),
-                                     'detected_version': detected.get('version'),
-                                     'detected_latest': detected.get('latest'),
-                                     'detected_purls': detected.get('purls'),
-                                     'detected_url': detected.get('url'),
-                                     'detected_path': detected.get('file', ''),
-                                     'detected_match': matched, 'detected_lines': lines,
-                                     'detected_oss_lines': oss_lines
-                                     })
+                    csv_dict.append(
+                        {
+                            'inventory_id': row_id,
+                            'path': f,
+                            'detected_usage': id_details,
+                            'detected_component': detected.get('component'),
+                            'detected_license': detected.get('licenses'),
+                            'detected_version': detected.get('version'),
+                            'detected_latest': detected.get('latest'),
+                            'detected_purls': detected.get('purls'),
+                            'detected_url': detected.get('url'),
+                            'detected_path': detected.get('file', ''),
+                            'detected_match': matched,
+                            'detected_lines': lines,
+                            'detected_oss_lines': oss_lines,
+                        }
+                    )
                     row_id = row_id + 1
         return csv_dict
 
@@ -170,20 +187,34 @@ class CsvOutput(ScanossBase):
         :return: True if successful, False otherwise
         """
         csv_data = self.parse(data)
-        if not csv_data:
+        if csv_data is None:
             self.print_stderr('ERROR: No CSV data returned for the JSON string provided.')
             return False
+        if len(csv_data) == 0:
+            self.print_msg('Warning: Empty scan results - generating CSV with headers only.')
         # Header row/column details
-        fields = ['inventory_id', 'path', 'detected_usage', 'detected_component', 'detected_license',
-                  'detected_version', 'detected_latest', 'detected_purls', 'detected_url', 'detected_match',
-                  'detected_lines', 'detected_oss_lines', 'detected_path']
+        fields = [
+            'inventory_id',
+            'path',
+            'detected_usage',
+            'detected_component',
+            'detected_license',
+            'detected_version',
+            'detected_latest',
+            'detected_purls',
+            'detected_url',
+            'detected_match',
+            'detected_lines',
+            'detected_oss_lines',
+            'detected_path',
+        ]
         file = sys.stdout
         if not output_file and self.output_file:
             output_file = self.output_file
         if output_file:
             file = open(output_file, 'w')
         writer = csv.DictWriter(file, fieldnames=fields)
-        writer.writeheader()        # writing headers (field names)
+        writer.writeheader()  # writing headers (field names)
         writer.writerows(csv_data)  # writing data rows
         if output_file:
             file.close()
@@ -206,6 +237,8 @@ class CsvOutput(ScanossBase):
             self.print_stderr(f'ERROR: Problem parsing input JSON: {e}')
             return False
         return self.produce_from_json(data, output_file)
+
+
 #
 # End of CsvOutput Class
 #