credsweeper 1.11.2__py3-none-any.whl → 1.11.4__py3-none-any.whl

credsweeper/deep_scanner/deep_scanner.py

@@ -1,8 +1,9 @@
+import contextlib
 import datetime
 import logging
 from typing import List, Optional, Any, Tuple, Union
 
-from credsweeper.common.constants import RECURSIVE_SCAN_LIMITATION
+from credsweeper.common.constants import RECURSIVE_SCAN_LIMITATION, MIN_DATA_LEN, MIN_VALUE_LENGTH
 from credsweeper.config import Config
 from credsweeper.credentials import Candidate
 from credsweeper.credentials.augment_candidates import augment_candidates
@@ -16,6 +17,7 @@ from credsweeper.scanner import Scanner
 from credsweeper.utils import Util
 from .byte_scanner import ByteScanner
 from .bzip2_scanner import Bzip2Scanner
+from .deb_scanner import DebScanner
 from .docx_scanner import DocxScanner
 from .eml_scanner import EmlScanner
 from .encoder_scanner import EncoderScanner
@@ -23,6 +25,7 @@ from .gzip_scanner import GzipScanner
 from .html_scanner import HtmlScanner
 from .jks_scanner import JksScanner
 from .lang_scanner import LangScanner
+from .lzma_scanner import LzmaScanner
 from .mxfile_scanner import MxfileScanner
 from .pdf_scanner import PdfScanner
 from .pkcs12_scanner import Pkcs12Scanner
@@ -48,10 +51,12 @@ class DeepScanner(
     HtmlScanner,  #
     JksScanner,  #
     LangScanner,  #
+    LzmaScanner,  #
     PdfScanner,  #
     Pkcs12Scanner,  #
     PptxScanner,  #
     TarScanner,  #
+    DebScanner,  #
     XmlScanner,  #
     XlsxScanner,  #
     ZipScanner
@@ -106,9 +111,15 @@ class DeepScanner(
         elif Util.is_bzip2(data):
             if 0 < depth:
                 deep_scanners.append(Bzip2Scanner)
+        elif Util.is_lzma(data):
+            if 0 < depth:
+                deep_scanners.append(LzmaScanner)
         elif Util.is_tar(data):
             if 0 < depth:
                 deep_scanners.append(TarScanner)
+        elif Util.is_deb(data):
+            if 0 < depth:
+                deep_scanners.append(DebScanner)
         elif Util.is_gzip(data):
             if 0 < depth:
                 deep_scanners.append(GzipScanner)
@@ -140,13 +151,16 @@ class DeepScanner(
             else:
                 fallback_scanners.append(EmlScanner)
             fallback_scanners.append(ByteScanner)
+        elif Util.is_known(data):
+            # the format is known but cannot be scanned
+            pass
         elif not Util.is_binary(data):
             if 0 < depth:
                 deep_scanners.append(EncoderScanner)
                 deep_scanners.append(LangScanner)
             deep_scanners.append(ByteScanner)
         else:
-            logger.warning("Cannot apply a deep scanner for type %s", file_type)
+            logger.warning("Cannot apply a deep scanner for type %s prefix %s", file_type, str(data[:MIN_DATA_LEN]))
         return deep_scanners, fallback_scanners
 
     # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
@@ -175,7 +189,7 @@ class DeepScanner(
             # this scan is successful, so fallback is not necessary
             fallback = False
         if fallback:
-            for scan_class in deep_scanners:
+            for scan_class in fallback_scanners:
                 fallback_candidates = scan_class.data_scan(self, data_provider, depth, recursive_limit_size)
                 if fallback_candidates is None:
                     continue
@@ -201,10 +215,10 @@ class DeepScanner(
                                                                   int) else RECURSIVE_SCAN_LIMITATION
         candidates: List[Candidate] = []
         data: Optional[bytes] = None
-        if isinstance(content_provider, TextContentProvider) or isinstance(content_provider, ByteContentProvider):
+        if isinstance(content_provider, (TextContentProvider, ByteContentProvider)):
             # Feature to scan files which might be containers
             data = content_provider.data
-            info = "FILE"
+            info = f"FILE:{content_provider.file_path}"
         elif isinstance(content_provider, DiffContentProvider) and content_provider.diff:
             candidates = self.scanner.scan(content_provider)
             # Feature to scan binary diffs
@@ -212,7 +226,7 @@ class DeepScanner(
             # the check for legal fix mypy issue
             if isinstance(diff, bytes):
                 data = diff
-            info = "DIFF"
+            info = f"DIFF:{content_provider.file_path}"
         else:
             logger.warning(f"Content provider {type(content_provider)} does not support deep scan")
             info = "NA"
@@ -239,15 +253,18 @@ class DeepScanner(
                 recursive_limit_size: maximal bytes of opened files to prevent recursive zip-bomb attack
         """
         candidates: List[Candidate] = []
-        logger.debug("Start data_scan: size=%d, depth=%d, limit=%d, path=%s, info=%s", len(data_provider.data), depth,
-                     recursive_limit_size, data_provider.file_path, data_provider.info)
-
         if 0 > depth:
             # break recursion if maximal depth is reached
-            logger.debug("bottom reached %s recursive_limit_size:%d", data_provider.file_path, recursive_limit_size)
+            logger.debug("Bottom reached %s recursive_limit_size:%d", data_provider.file_path, recursive_limit_size)
             return candidates
-
         depth -= 1
+        if MIN_DATA_LEN > len(data_provider.data):
+            # break recursion for minimal data size
+            logger.debug("Too small data: size=%d, depth=%d, limit=%d, path=%s, info=%s", len(data_provider.data),
+                         depth, recursive_limit_size, data_provider.file_path, data_provider.info)
+            return candidates
+        logger.debug("Start data_scan: size=%d, depth=%d, limit=%d, path=%s, info=%s", len(data_provider.data), depth,
+                     recursive_limit_size, data_provider.file_path, data_provider.info)
 
         if FilePathExtractor.is_find_by_ext_file(self.config, data_provider.file_type):
             # Skip scanning file and makes fake candidate due the extension is suspicious
@@ -287,7 +304,7 @@ class DeepScanner(
         items: List[Tuple[Union[int, str], Any]] = []
         struct_key: Optional[str] = None
         struct_value: Optional[str] = None
-        line_for_keyword_rules = ""
+        lines_for_keyword_rules = []
         if isinstance(struct_provider.struct, dict):
             for key, value in struct_provider.struct.items():
                 if isinstance(value, (list, tuple)) and 1 == len(value):
@@ -298,13 +315,13 @@ class DeepScanner(
             # for transformation {"key": "api_key", "value": "XXXXXXX"} -> {"api_key": "XXXXXXX"}
             struct_key = struct_provider.struct.get("key")
             struct_value = struct_provider.struct.get("value")
-        elif isinstance(struct_provider.struct, list) or isinstance(struct_provider.struct, tuple):
+        elif isinstance(struct_provider.struct, (list, tuple)):
             items = list(enumerate(struct_provider.struct))
         else:
             logger.error("Not supported type:%s val:%s", str(type(struct_provider.struct)), str(struct_provider.struct))
 
         for key, value in items:
-            if isinstance(value, dict) or isinstance(value, (list, tuple)) and 1 < len(value):
+            if isinstance(value, dict) or isinstance(value, (list, tuple)) and 1 <= len(value):
                 val_struct_provider = StructContentProvider(struct=value,
                                                             file_path=struct_provider.file_path,
                                                             file_type=struct_provider.file_type,
@@ -313,52 +330,57 @@ class DeepScanner(
                 candidates.extend(new_candidates)
 
             elif isinstance(value, bytes):
-                bytes_struct_provider = DataContentProvider(data=value,
-                                                            file_path=struct_provider.file_path,
-                                                            file_type=struct_provider.file_type,
-                                                            info=f"{struct_provider.info}|BYTES:{key}")
-                new_limit = recursive_limit_size - len(value)
-                new_candidates = self.recursive_scan(bytes_struct_provider, depth, new_limit)
-                candidates.extend(new_candidates)
+                if MIN_DATA_LEN <= len(value):
+                    bytes_struct_provider = DataContentProvider(data=value,
+                                                                file_path=struct_provider.file_path,
+                                                                file_type=struct_provider.file_type,
+                                                                info=f"{struct_provider.info}|BYTES:{key}")
+                    new_limit = recursive_limit_size - len(value)
+                    new_candidates = self.recursive_scan(bytes_struct_provider, depth, new_limit)
+                    candidates.extend(new_candidates)
+                if MIN_VALUE_LENGTH <= len(value) and isinstance(key, str) \
+                        and self.scanner.keywords_required_substrings_check(key.lower()):
+                    str_val = str(value)
+                    lines_for_keyword_rules.append(f"{key} = '{str_val}'" if '"' in str_val else f'{key} = "{str_val}"')
 
             elif isinstance(value, str):
-                data = value.encode(encoding=DEFAULT_ENCODING, errors='replace')
-                str_struct_provider = DataContentProvider(data=data,
-                                                          file_path=struct_provider.file_path,
-                                                          file_type=struct_provider.file_type,
-                                                          info=f"{struct_provider.info}|STRING:{key}")
-                new_limit = recursive_limit_size - len(str_struct_provider.data)
-                new_candidates = self.recursive_scan(str_struct_provider, depth, new_limit)
-                candidates.extend(new_candidates)
-
+                if MIN_DATA_LEN <= len(value):
+                    # recursive scan only for data which may be decoded at least
+                    with contextlib.suppress(UnicodeError):
+                        data = value.encode(encoding=DEFAULT_ENCODING, errors='strict')
+                        str_struct_provider = DataContentProvider(data=data,
+                                                                  file_path=struct_provider.file_path,
+                                                                  file_type=struct_provider.file_type,
+                                                                  info=f"{struct_provider.info}|STRING:{key}")
+                        new_limit = recursive_limit_size - len(str_struct_provider.data)
+                        new_candidates = self.recursive_scan(str_struct_provider, depth, new_limit)
+                        candidates.extend(new_candidates)
                 # use key = "value" scan for common cases like in TOML
-                if isinstance(key, str) and self.scanner.keywords_required_substrings_check(key):
-                    line_for_keyword_rules += f"{key} = \"{value}\"; "
+                if MIN_VALUE_LENGTH <= len(value) and isinstance(key, str) \
+                        and self.scanner.keywords_required_substrings_check(key.lower()):
+                    lines_for_keyword_rules.append(f"{key} = '{value}'" if '"' in value else f'{key} = "{value}"')
 
             elif isinstance(value, (int, float, datetime.date, datetime.datetime)):
-                # use the fields only in case of matched keywords
-                if isinstance(key, str) and self.scanner.keywords_required_substrings_check(key):
-                    line_for_keyword_rules += f"{key} = \"{value}\"; "
-
+                # skip useless types
+                pass
             else:
                 logger.warning("Not supported type:%s value(%s)", str(type(value)), str(value))
 
-        if line_for_keyword_rules:
-            str_provider = StringContentProvider([line_for_keyword_rules],
+        if lines_for_keyword_rules:
+            str_provider = StringContentProvider(lines_for_keyword_rules,
                                                  file_path=struct_provider.file_path,
-                                                 file_type=".toml",
-                                                 info=f"{struct_provider.info}|KEYWORD:`{line_for_keyword_rules}`")
+                                                 file_type=".py",
+                                                 info=f"{struct_provider.info}|KEYWORD:`{lines_for_keyword_rules}`")
             new_candidates = self.scanner.scan(str_provider)
             augment_candidates(candidates, new_candidates)
 
         # last check when dictionary is {"key": "api_key", "value": "XXXXXXX"} -> {"api_key": "XXXXXXX"}
         if isinstance(struct_key, str) and isinstance(struct_value, str):
-            line_for_keyword_rules = f"{struct_key} = \"{struct_value}\""
             key_value_provider = StringContentProvider(
-                [line_for_keyword_rules],
+                [f"{struct_key} = '{struct_value}'" if '"' in struct_value else f'{struct_key} = "{struct_value}"'],
                 file_path=struct_provider.file_path,
                 file_type=".toml",
-                info=f"{struct_provider.info}|KEY_VALUE:`{line_for_keyword_rules}`")
+                info=f"{struct_provider.info}|KEY_VALUE:`{lines_for_keyword_rules}`")
             new_candidates = self.scanner.scan(key_value_provider)
             augment_candidates(candidates, new_candidates)
         return candidates

credsweeper/deep_scanner/docx_scanner.py

@@ -42,7 +42,7 @@ class DocxScanner(AbstractScanner, ABC):
             yield from DocxScanner._iter_block_items(block.footer)
             return
         elif isinstance(block, _Cell):
-            parent_elm = block._tc
+            parent_elm = block._tc  # pylint: disable=W0212
         else:
             raise ValueError(f"unrecognised:{type(block)}")
 

credsweeper/deep_scanner/encoder_scanner.py

@@ -18,11 +18,11 @@ class EncoderScanner(AbstractScanner, ABC):
             depth: int,  #
             recursive_limit_size: int) -> Optional[List[Candidate]]:
         """Tries to decode data from base64 encode to bytes and scan as bytes again"""
-        if data_provider.represent_as_encoded():
+        if result := data_provider.represent_as_encoded():
             decoded_data_provider = DataContentProvider(data=data_provider.decoded,
                                                         file_path=data_provider.file_path,
                                                         file_type=data_provider.file_type,
                                                         info=f"{data_provider.info}|BASE64")
             new_limit = recursive_limit_size - len(decoded_data_provider.data)
             return self.recursive_scan(decoded_data_provider, depth, new_limit)
-        return None
+        return None if result is None else []

credsweeper/deep_scanner/gzip_scanner.py

@@ -31,7 +31,7 @@ class GzipScanner(AbstractScanner, ABC):
                 gzip_content_provider = DataContentProvider(data=f.read(),
                                                             file_path=new_path,
                                                             file_type=Util.get_extension(new_path),
-                                                            info=f"{data_provider.info}|GZIP:{file_path}")
+                                                            info=f"{data_provider.info}|GZIP:{new_path}")
                 new_limit = recursive_limit_size - len(gzip_content_provider.data)
                 gzip_candidates = self.recursive_scan(gzip_content_provider, depth, new_limit)
                 return gzip_candidates

credsweeper/deep_scanner/html_scanner.py

@@ -19,12 +19,12 @@ class HtmlScanner(AbstractScanner, ABC):
             depth: int,  #
             recursive_limit_size: int) -> Optional[List[Candidate]]:
         """Tries to represent data as html text and scan as text lines"""
-        if data_provider.represent_as_html(depth, recursive_limit_size,
-                                           self.scanner.keywords_required_substrings_check):
+        if result := data_provider.represent_as_html(depth, recursive_limit_size,
+                                                     self.scanner.keywords_required_substrings_check):
             string_data_provider = StringContentProvider(lines=data_provider.lines,
                                                          line_numbers=data_provider.line_numbers,
                                                          file_path=data_provider.file_path,
                                                          file_type=data_provider.file_type,
                                                          info=f"{data_provider.info}|HTML")
             return self.scanner.scan(string_data_provider)
-        return None
+        return None if result is None else []

credsweeper/deep_scanner/jks_scanner.py

@@ -20,7 +20,6 @@ class JksScanner(AbstractScanner, ABC):
             depth: int,  #
             recursive_limit_size: int) -> Optional[List[Candidate]]:
         """Tries to scan JKS to open with standard password"""
-        candidates = []
         for pw_probe in self.config.bruteforce_list:
             try:
                 keystore = jks.KeyStore.loads(data_provider.data, pw_probe, try_decrypt_keys=True)
@@ -38,8 +37,7 @@ class JksScanner(AbstractScanner, ABC):
                 candidate.line_data_list[0].value = pw_probe or "<EMPTY PASSWORD>"
                 candidate.line_data_list[0].value_start = 1
                 candidate.line_data_list[0].value_end = 1 + len(candidate.line_data_list[0].value)
-                candidates.append(candidate)
-                break
+                return [candidate]
             except Exception as jks_exc:
                 logger.debug(f"{data_provider.file_path}:{pw_probe}:{jks_exc}")
-        return candidates
+        return None

credsweeper/deep_scanner/lang_scanner.py

@@ -19,10 +19,10 @@ class LangScanner(AbstractScanner, ABC):
             depth: int,  #
             recursive_limit_size: int) -> Optional[List[Candidate]]:
         """Tries to represent data as markup language and scan as structure"""
-        if data_provider.represent_as_structure():
+        if result := data_provider.represent_as_structure():
             struct_data_provider = StructContentProvider(struct=data_provider.structure,
                                                          file_path=data_provider.file_path,
                                                          file_type=data_provider.file_type,
                                                          info=f"{data_provider.info}|STRUCT")
             return self.structure_scan(struct_data_provider, depth, recursive_limit_size)
-        return None
+        return None if result is None else []

credsweeper/deep_scanner/lzma_scanner.py

@@ -0,0 +1,40 @@
+import logging
+import lzma
+from abc import ABC
+from pathlib import Path
+from typing import List, Optional
+
+from credsweeper.credentials import Candidate
+from credsweeper.deep_scanner.abstract_scanner import AbstractScanner
+from credsweeper.file_handler.data_content_provider import DataContentProvider
+from credsweeper.utils import Util
+
+logger = logging.getLogger(__name__)
+
+
+class LzmaScanner(AbstractScanner, ABC):
+    """Implements lzma scanning"""
+
+    def data_scan(
+            self,  #
+            data_provider: DataContentProvider,  #
+            depth: int,  #
+            recursive_limit_size: int) -> Optional[List[Candidate]]:
+        """Extracts data from lzma archive and launches data_scan"""
+        try:
+            file_path = Path(data_provider.file_path)
+            new_path = file_path.as_posix()
+            if ".xz" == file_path.suffix:
+                new_path = new_path[:-3]
+            elif ".lzma" == file_path.suffix:
+                new_path = new_path[:-5]
+            lzma_content_provider = DataContentProvider(data=lzma.decompress(data_provider.data),
+                                                        file_path=new_path,
+                                                        file_type=Util.get_extension(new_path),
+                                                        info=f"{data_provider.info}|LZMA:{file_path}")
+            new_limit = recursive_limit_size - len(lzma_content_provider.data)
+            lzma_candidates = self.recursive_scan(lzma_content_provider, depth, new_limit)
+            return lzma_candidates
+        except Exception as lzma_exc:
+            logger.error(f"{data_provider.file_path}:{lzma_exc}")
+        return None

credsweeper/deep_scanner/pkcs12_scanner.py

@@ -20,10 +20,9 @@ class Pkcs12Scanner(AbstractScanner, ABC):
             depth: int,  #
             recursive_limit_size: int) -> Optional[List[Candidate]]:
         """Tries to scan PKCS12 to open with standard password"""
-        candidates = []
         for pw_probe in self.config.bruteforce_list:
             try:
-                (private_key, certificate, additional_certificates) \
+                (private_key, _certificate, _additional_certificates) \
                     = cryptography.hazmat.primitives.serialization.pkcs12.load_key_and_certificates(data_provider.data,
                                                                                                     pw_probe.encode())
                 # the password probe has passed, it will be the value
@@ -40,8 +39,7 @@ class Pkcs12Scanner(AbstractScanner, ABC):
                 candidate.line_data_list[0].value = value
                 candidate.line_data_list[0].value_start = 1
                 candidate.line_data_list[0].value_end = 1 + len(candidate.line_data_list[0].value)
-                candidates.append(candidate)
-                break
+                return [candidate]
             except Exception as pkcs_exc:
                 logger.debug(f"{data_provider.file_path}:{pw_probe}:{pkcs_exc}")
-        return candidates
+        return None

credsweeper/deep_scanner/xml_scanner.py

@@ -19,11 +19,11 @@ class XmlScanner(AbstractScanner, ABC):
             depth: int,  #
             recursive_limit_size: int) -> Optional[List[Candidate]]:
         """Tries to represent data as xml text and scan as text lines"""
-        if data_provider.represent_as_xml():
+        if result := data_provider.represent_as_xml():
             string_data_provider = StringContentProvider(lines=data_provider.lines,
                                                          line_numbers=data_provider.line_numbers,
                                                          file_path=data_provider.file_path,
                                                          file_type=data_provider.file_type,
                                                          info=f"{data_provider.info}|XML")
             return self.scanner.scan(string_data_provider)
-        return None
+        return None if result is None else []

credsweeper/file_handler/byte_content_provider.py

@@ -32,10 +32,10 @@ class ByteContentProvider(ContentProvider):
     def free(self) -> None:
         """free data after scan to reduce memory usage"""
         self.__data = None
-        if hasattr(self, "data"):
+        if "data" in self.__dict__:
             delattr(self, "data")
         self.__lines = None
-        if hasattr(self, "lines"):
+        if "lines" in self.__dict__:
             delattr(self, "lines")
 
     @cached_property

credsweeper/file_handler/content_provider.py

@@ -93,7 +93,7 @@ class ContentProvider(ABC):
             if min_len > len(line.strip()):
                 # Ignore target if stripped part is too short for all types
                 continue
-            elif MAX_LINE_LENGTH < len(line):
+            if MAX_LINE_LENGTH < len(line):
                 for chunk_start, chunk_end in Util.get_chunks(len(line)):
                     target = AnalysisTarget(
                         line_pos=line_pos,  #

credsweeper/file_handler/data_content_provider.py

@@ -54,10 +54,10 @@ class DataContentProvider(ContentProvider):
     def free(self) -> None:
         """free data after scan to reduce memory usage"""
         self.__data = None
-        if hasattr(self, "data"):
+        if "data" in self.__dict__:
             delattr(self, "data")
         self.__text = None
-        if hasattr(self, "text"):
+        if "text" in self.__dict__:
             delattr(self, "text")
         self.structure = None
         self.decoded = None
@@ -76,9 +76,14 @@ class DataContentProvider(ContentProvider):
         return self.structure is not None and (isinstance(self.structure, dict) and 0 < len(self.structure.keys())
                                                or isinstance(self.structure, list) and 0 < len(self.structure))
 
-    def represent_as_structure(self) -> bool:
+    def represent_as_structure(self) -> Optional[bool]:
         """Tries to convert data with many parsers. Stores result to internal structure
-        Return True if some structure found
+
+        Return:
+             True if some structure found
+             False if no data found
+             None if the format is not acceptable
+
         """
         if MIN_DATA_LEN > len(self.text):
             return False
@@ -134,13 +139,15 @@ class DataContentProvider(ContentProvider):
             if self.__is_structure():
                 return True
         # # # None of above
-        return False
+        return None
 
-    def represent_as_xml(self) -> bool:
+    def represent_as_xml(self) -> Optional[bool]:
         """Tries to read data as xml
 
         Return:
              True if reading was successful
+             False if no data found
+             None if the format is not acceptable
 
         """
         if MIN_XML_LEN > len(self.text):
@@ -150,14 +157,12 @@ class DataContentProvider(ContentProvider):
                 xml_text = self.text.splitlines()
                 self.lines, self.line_numbers = Util.get_xml_from_lines(xml_text)
                 logger.debug("CONVERTED from xml")
+                return bool(self.lines and self.line_numbers)
             else:
                 logger.debug("Weak data to parse as XML")
-                return False
         except Exception as exc:
             logger.debug("Cannot parse as XML:%s %s", exc, self.data)
-        else:
-            return bool(self.lines and self.line_numbers)
-        return False
+        return None
 
     def _check_multiline_cell(self, cell: Tag) -> Optional[Tuple[int, str]]:
         """multiline cell will be analysed as text or return single line from cell
@@ -336,11 +341,13 @@ class DataContentProvider(ContentProvider):
             self,  #
             depth: int,  #
             recursive_limit_size: int,  #
-            keywords_required_substrings_check: Callable[[str], bool]) -> bool:
+            keywords_required_substrings_check: Callable[[str], bool]) -> Optional[bool]:
         """Tries to read data as html
 
         Return:
              True if reading was successful
+             False if no data found
+             None if the format is not acceptable
 
         """
         try:
@@ -361,13 +368,15 @@ class DataContentProvider(ContentProvider):
             logger.debug("Cannot parse as HTML:%s %s", exc, self.data)
         else:
             return bool(self.lines and self.line_numbers)
-        return False
+        return None
 
-    def represent_as_encoded(self) -> bool:
+    def represent_as_encoded(self) -> Optional[bool]:
         """Decodes data from base64. Stores result in decoded
 
         Return:
              True if the data correctly parsed and verified
+             False if no data found
+             None if the format is not acceptable
 
         """
         if len(self.data) < MIN_ENCODED_DATA_LEN \
@@ -383,7 +392,7 @@ class DataContentProvider(ContentProvider):
             logger.debug("Cannot decoded as base64:%s %s", exc, self.data)
         else:
             return self.decoded is not None and 0 < len(self.decoded)
-        return False
+        return None
 
     def yield_analysis_target(self, min_len: int) -> Generator[AnalysisTarget, None, None]:
         """Return nothing. The class provides only data storage.

credsweeper/file_handler/diff_content_provider.py

@@ -48,8 +48,8 @@ class DiffContentProvider(ContentProvider):
 
     def free(self) -> None:
         """free data after scan to reduce memory usage"""
-        self.__diff = None
-        if hasattr(self, "diff"):
+        self.__diff = []
+        if "diff" in self.__dict__:
             delattr(self, "diff")
 
     @staticmethod

credsweeper/file_handler/file_path_extractor.py

@@ -162,7 +162,7 @@ class FilePathExtractor:
             True when the file is oversize or less than MIN_DATA_LEN, or unsupported
         """
         path = reference[1] if isinstance(reference, tuple) else reference
-        if isinstance(path, str) or isinstance(path, Path):
+        if isinstance(path, (str, Path)):
             file_size = os.path.getsize(path)
         elif isinstance(path, io.BytesIO):
             current_pos = path.tell()

credsweeper/file_handler/files_provider.py

@@ -42,7 +42,7 @@ class FilesProvider(AbstractProvider):
         """
         text_content_provider_list: List[Union[DiffContentProvider, TextContentProvider]] = []
         for path in self.paths:
-            if isinstance(path, str) or isinstance(path, Path):
+            if isinstance(path, (str, Path)):
                 new_files = FilePathExtractor.get_file_paths(config, path)
                 if self.skip_ignored:
                     new_files = FilePathExtractor.apply_gitignore(new_files)
@@ -50,9 +50,7 @@ class FilesProvider(AbstractProvider):
                     text_content_provider_list.append(TextContentProvider(_file))
             elif isinstance(path, io.BytesIO):
                 text_content_provider_list.append(TextContentProvider((":memory:", path)))
-            elif isinstance(path, tuple) \
-                    and (isinstance(path[0], str) or isinstance(path[0], Path)) \
-                    and isinstance(path[1], io.BytesIO):
+            elif isinstance(path, tuple) and (isinstance(path[0], (str, Path))) and isinstance(path[1], io.BytesIO):
                 # suppose, all the files must be scanned
                 text_content_provider_list.append(TextContentProvider(path))
             else:

credsweeper/file_handler/patches_provider.py

@@ -37,7 +37,7 @@ class PatchesProvider(AbstractProvider):
         for file_path in self.paths:
             if FilePathExtractor.check_file_size(config, file_path):
                 continue
-            if isinstance(file_path, str) or isinstance(file_path, Path):
+            if isinstance(file_path, (str, Path)):
                 raw_patches.append(Util.read_file(file_path))
             elif isinstance(file_path, io.BytesIO):
                 the_patch = Util.decode_bytes(file_path.read())

credsweeper/file_handler/string_content_provider.py

@@ -38,10 +38,10 @@ class StringContentProvider(ContentProvider):
     def free(self) -> None:
         """free data after scan to reduce memory usage"""
         self.__lines = []
-        if hasattr(self, "lines"):
+        if "lines" in self.__dict__:
             delattr(self, "lines")
         self.__line_numbers = []
-        if hasattr(self, "line_numbers"):
+        if "line_numbers" in self.__dict__:
             delattr(self, "line_numbers")
 
     @cached_property

credsweeper/file_handler/struct_content_provider.py

@@ -38,7 +38,7 @@ class StructContentProvider(ContentProvider):
     def free(self) -> None:
         """free data after scan to reduce memory usage"""
         self.__struct = None
-        if hasattr(self, "struct"):
+        if "struct" in self.__dict__:
             delattr(self, "struct")
 
     def yield_analysis_target(self, min_len: int) -> Generator[AnalysisTarget, None, None]:

credsweeper/file_handler/text_content_provider.py

@@ -42,10 +42,10 @@ class TextContentProvider(ContentProvider):
     def free(self) -> None:
         """free data after scan to reduce memory usage"""
         self.__data = None
-        if hasattr(self, "data"):
+        if "data" in self.__dict__:
             delattr(self, "data")
         self.__lines = None
-        if hasattr(self, "lines"):
+        if "lines" in self.__dict__:
             delattr(self, "lines")
         if isinstance(self.__io, io.BytesIO) and self.__io and not self.__io.closed:
             self.__io.close()