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

credsweeper/filters/value_array_dictionary_check.py

@@ -14,7 +14,7 @@ class ValueArrayDictionaryCheck(Filter):
         `token = {'root'}` would be kept
     """
 
-    PATTERN = re.compile(r"\[('|\")?.+('|\")?\]")
+    PATTERN = re.compile(r"\[('|\")?[^,]+('|\")?\]")
 
     def __init__(self, config: Config = None) -> None:
         pass
@@ -32,6 +32,8 @@ class ValueArrayDictionaryCheck(Filter):
         """
         if line_data.is_well_quoted_value:
             return False
+        if line_data.wrap and "byte" in line_data.wrap.lower():
+            return False
         if self.PATTERN.search(line_data.value):
             return True
         if line_data.wrap and not line_data.is_well_quoted_value and ('[' in line_data.wrap or '(' in line_data.wrap):

credsweeper/filters/value_azure_token_check.py

@@ -1,7 +1,6 @@
 import contextlib
 import json
 
-from credsweeper.common.constants import Chars
 from credsweeper.config import Config
 from credsweeper.credentials import LineData
 from credsweeper.file_handler.analysis_target import AnalysisTarget
@@ -45,7 +44,7 @@ class ValueAzureTokenCheck(Filter):
                 # must be all parts in payload
                 return True
             min_entropy = ValueEntropyBase64Check.get_min_data_entropy(len(parts[2]))
-            entropy = Util.get_shannon_entropy(parts[2], Chars.BASE64URL_CHARS.value)
+            entropy = Util.get_shannon_entropy(parts[2])
             # good signature has to be like random bytes
             return entropy < min_entropy
 

credsweeper/filters/value_base64_encoded_pem_check.py

@@ -30,7 +30,7 @@ class ValueBase64EncodedPem(Filter):
         with contextlib.suppress(Exception):
             text = Util.decode_base64(line_data.value, padding_safe=True, urlsafe_detect=True)
             lines = text.decode(ASCII).splitlines()
-            lines_pos = [x for x in range(len(lines))]
+            lines_pos = list(range(len(lines)))
             for line_pos, line in zip(lines_pos, lines):
                 if PEM_BEGIN_PATTERN in line:
                     new_target = AnalysisTarget(line_pos, lines, lines_pos, target.descriptor)

credsweeper/filters/value_base64_part_check.py

@@ -1,6 +1,7 @@
 import contextlib
 import re
 import statistics
+from itertools import takewhile
 
 from credsweeper.common.constants import Chars
 from credsweeper.config import Config
@@ -16,8 +17,8 @@ class ValueBase64PartCheck(Filter):
     Check that candidate is NOT a part of base64 long line
     """
 
-    base64_pattern = re.compile(r"^(\\{1,8}[0abfnrtv]|[0-9A-Za-z+/=]){1,4000}")
-    base64_set = set(Chars.BASE64STDPAD_CHARS.value)
+    base64_pattern = re.compile(r"^(\\{1,8}[0abfnrtv]|[0-9A-Za-z+/=]){1,4000}$")
+    base64_char_set = set(Chars.BASE64STDPAD_CHARS.value + '\\')
 
     def __init__(self, config: Config = None) -> None:
         pass
@@ -64,38 +65,46 @@ class ValueBase64PartCheck(Filter):
                 elif right_end - left_start >= 2 * len_value:
                     # simple analysis for data too large to yield sensible insights
                     part_set = set(line[left_start:right_end])
-                    if not part_set.difference(self.base64_set):
+                    if not part_set.difference(ValueBase64PartCheck.base64_char_set):
                         # obvious case: all characters are base64 standard
                         return True
 
-                left_part = line[left_start:line_data.value_start]
-                len_left = len(left_part)
-                right_part = line[line_data.value_end:right_end]
-                len_right = len(right_part)
+                left_part = ''.join(
+                    takewhile(lambda x: x in ValueBase64PartCheck.base64_char_set,
+                              reversed(line[left_start:line_data.value_start])))
+
+                right_part = ''.join(
+                    takewhile(lambda x: x in ValueBase64PartCheck.base64_char_set, line[line_data.value_end:right_end]))
 
                 min_entropy_value = ValueEntropyBase64Check.get_min_data_entropy(len_value)
-                value_entropy = Util.get_shannon_entropy(value, Chars.BASE64STD_CHARS.value)
 
-                if ValueEntropyBase64Check.min_length < len_left:
-                    left_entropy = Util.get_shannon_entropy(left_part, Chars.BASE64STD_CHARS.value)
-                    if len_left < len_value:
-                        left_entropy *= len_value / len_left
-                else:
-                    left_entropy = min_entropy_value
+                left_entropy = Util.get_shannon_entropy(left_part)
+                value_entropy = Util.get_shannon_entropy(value)
+                right_entropy = Util.get_shannon_entropy(right_part)
+                common = left_part + value + right_part
+                common_entropy = Util.get_shannon_entropy(common)
+                min_entropy_common = ValueEntropyBase64Check.get_min_data_entropy(len(common))
+                if min_entropy_common < common_entropy:
+                    return True
 
-                if ValueEntropyBase64Check.min_length < len_right:
-                    right_entropy = Util.get_shannon_entropy(right_part, Chars.BASE64STD_CHARS.value)
-                    if len_right < len_value:
-                        left_entropy *= len_right / len_left
+                if left_entropy and right_entropy:
+                    data = [left_entropy, value_entropy, right_entropy, min_entropy_value, common_entropy]
+                elif left_entropy and not right_entropy:
+                    data = [left_entropy, value_entropy, min_entropy_value, min_entropy_value, common_entropy]
+                elif not left_entropy and right_entropy:
+                    data = [value_entropy, right_entropy, min_entropy_value, min_entropy_value, common_entropy]
                 else:
-                    right_entropy = min_entropy_value
+                    return False
 
-                data = [left_entropy, value_entropy, right_entropy, min_entropy_value]
                 avg = statistics.mean(data)
                 stdev = statistics.stdev(data, avg)
                 avg_min = avg - 1.1 * stdev
-                if avg_min <= left_entropy and avg_min <= right_entropy:
+                if (0. == left_entropy or avg_min < left_entropy or left_entropy < value_entropy < right_entropy) \
+                        and (
+                        0. == right_entropy or avg_min < right_entropy or right_entropy < value_entropy < left_entropy):
                     # high entropy of bound parts looks like a part of base64 long line
                     return True
+                else:
+                    return False
 
         return False

credsweeper/filters/value_discord_bot_check.py

@@ -1,6 +1,5 @@
 import contextlib
 
-from credsweeper.common.constants import Chars
 from credsweeper.config import Config
 from credsweeper.credentials import LineData
 from credsweeper.file_handler.analysis_target import AnalysisTarget
@@ -32,7 +31,7 @@ class ValueDiscordBotCheck(Filter):
             id_part = line_data.value[:dot_separator_index]
             discord_id = int(Util.decode_base64(id_part, padding_safe=True, urlsafe_detect=True))
             entropy_part = line_data.value[dot_separator_index:]
-            entropy = Util.get_shannon_entropy(entropy_part, Chars.BASE64URL_CHARS.value)
+            entropy = Util.get_shannon_entropy(entropy_part)
             min_entropy = ValueEntropyBase64Check.get_min_data_entropy(len(entropy_part))
             if 1000 <= discord_id and min_entropy <= entropy:
                 return False

credsweeper/filters/value_entropy_base32_check.py

@@ -1,42 +1,22 @@
 import math
+from functools import cache
 
-from credsweeper.common.constants import Chars
-from credsweeper.config import Config
-from credsweeper.credentials import LineData
-from credsweeper.file_handler.analysis_target import AnalysisTarget
-from credsweeper.filters import Filter
-from credsweeper.utils import Util
+from credsweeper.filters.value_entropy_base_check import ValueEntropyBaseCheck
 
 
-class ValueEntropyBase32Check(Filter):
-    """Check that candidate have Shanon Entropy (for [a-z0-9])"""
-
-    def __init__(self, config: Config = None) -> None:
-        pass
+class ValueEntropyBase32Check(ValueEntropyBaseCheck):
+    """Base32 entropy check"""
 
     @staticmethod
+    @cache
     def get_min_data_entropy(x: int) -> float:
         """Returns average entropy for size of random data. Precalculated data is applied for speedup"""
-        if 16 == x:
-            y = 3.46
-        elif 10 <= x:
-            # approximation does not exceed stdev
-            y = 0.64 * math.log2(x) + 0.9
+        if 8 <= x < 17:
+            y = 0.80569236 * math.log2(x) + 0.13439734
+        elif 17 <= x < 33:
+            y = 0.66350481 * math.log2(x) + 0.71143862
+        elif 33 <= x:
+            y = 4.04
         else:
             y = 0
         return y
-
-    def run(self, line_data: LineData, target: AnalysisTarget) -> bool:
-        """Run filter checks on received credential candidate data 'line_data'.
-
-        Args:
-            line_data: credential candidate data
-            target: multiline target from which line data was obtained
-
-        Return:
-            True, if need to filter candidate and False if left
-
-        """
-        entropy = Util.get_shannon_entropy(line_data.value, Chars.BASE32_CHARS.value)
-        min_entropy = ValueEntropyBase32Check.get_min_data_entropy(len(line_data.value))
-        return min_entropy > entropy or 0 == min_entropy

credsweeper/filters/value_entropy_base36_check.py

@@ -1,46 +1,23 @@
 import math
+from functools import cache
 
-from credsweeper.common.constants import Chars
-from credsweeper.config import Config
-from credsweeper.credentials import LineData
-from credsweeper.file_handler.analysis_target import AnalysisTarget
-from credsweeper.filters import Filter
-from credsweeper.utils import Util
+from credsweeper.filters.value_entropy_base_check import ValueEntropyBaseCheck
 
 
-class ValueEntropyBase36Check(Filter):
-    """Check that candidate have Shanon Entropy (for [a-z0-9])"""
-
-    def __init__(self, config: Config = None) -> None:
-        pass
+class ValueEntropyBase36Check(ValueEntropyBaseCheck):
+    """Base36 entropy check"""
 
     @staticmethod
+    @cache
     def get_min_data_entropy(x: int) -> float:
         """Returns minimal entropy for size of random data. Precalculated data is applied for speedup"""
         if 15 == x:
-            y = 3.43
-        elif 24 == x:
-            y = 3.91
-        elif 25 == x:
-            y = 3.95
-        elif 10 <= x:
-            # approximation does not exceed standard deviation
-            y = 0.7 * math.log2(x) + 0.7
+            # workaround for Dropbox App secret
+            y = 3.374
+        elif 10 <= x < 26:
+            y = 0.731566857 * math.log2(x) + 0.474132
+        elif 26 <= x:
+            y = 3.9
         else:
             y = 0
         return y
-
-    def run(self, line_data: LineData, target: AnalysisTarget) -> bool:
-        """Run filter checks on received credential candidate data 'line_data'.
-
-        Args:
-            line_data: credential candidate data
-            target: multiline target from which line data was obtained
-
-        Return:
-            True, if need to filter candidate and False if left
-
-        """
-        entropy = Util.get_shannon_entropy(line_data.value, Chars.BASE36_CHARS.value)
-        min_entropy = ValueEntropyBase36Check.get_min_data_entropy(len(line_data.value))
-        return min_entropy > entropy or 0 == min_entropy

credsweeper/filters/value_entropy_base64_check.py

@@ -1,59 +1,26 @@
 import math
+from functools import cache
 
-from credsweeper.common.constants import Chars, ENTROPY_LIMIT_BASE64
-from credsweeper.config import Config
-from credsweeper.credentials import LineData
-from credsweeper.file_handler.analysis_target import AnalysisTarget
-from credsweeper.filters import Filter
-from credsweeper.utils import Util
+from credsweeper.filters.value_entropy_base_check import ValueEntropyBaseCheck
 
 
-class ValueEntropyBase64Check(Filter):
-    """Check that candidate have Shanon Entropy > 3 (for HEX_CHARS or BASE36_CHARS) or > 4.5 (for BASE64_CHARS)."""
-
-    # If the value size is less than this value the entropy evaluation gives an imprecise result
-    min_length = 12
-
-    def __init__(self, config: Config = None) -> None:
-        pass
+class ValueEntropyBase64Check(ValueEntropyBaseCheck):
+    """Base64 entropy check"""
 
     @staticmethod
+    @cache
     def get_min_data_entropy(x: int) -> float:
         """Returns minimal average entropy for size of random data. Precalculated round data is applied for speedup"""
-        if 18 == x:
-            y = 3.8
-        elif 20 == x:
-            y = 3.9
-        elif 24 == x:
-            y = 4.1
-        elif 32 == x:
-            y = 4.4
-        elif ValueEntropyBase64Check.min_length <= x < 35:
-            # logarithm base 2 - slow, but precise. Approximation does not exceed stdev
-            y = 0.77 * math.log2(x) + 0.62
-        elif 35 <= x < 60:
-            y = ENTROPY_LIMIT_BASE64
-        elif 60 <= x:
-            # the entropy grows slowly after 60
-            y = 5.0
+        if 12 <= x < 18:
+            y = 0.915 * math.log2(x) - 0.047
+        elif 18 <= x < 35:
+            y = 0.767 * math.log2(x) + 0.5677
+        elif 35 <= x < 65:
+            y = 0.944 * math.log2(x) - 0.009 * x - 0.04
+        elif 65 <= x < 256:
+            y = 0.621 * math.log2(x) - 0.003 * x + 1.54
+        elif 256 <= x:
+            y = 6 - 64 / x
         else:
             y = 0
         return y
-
-    def run(self, line_data: LineData, target: AnalysisTarget) -> bool:
-        """Run filter checks on received credential candidate data 'line_data'.
-
-        Args:
-            line_data: credential candidate data
-            target: multiline target from which line data was obtained
-
-        Return:
-            True, if need to filter candidate and False if left
-
-        """
-        if '-' in line_data.value or '_' in line_data.value:
-            entropy = Util.get_shannon_entropy(line_data.value, Chars.BASE64URL_CHARS.value)
-        else:
-            entropy = Util.get_shannon_entropy(line_data.value, Chars.BASE64STD_CHARS.value)
-        min_entropy = ValueEntropyBase64Check.get_min_data_entropy(len(line_data.value))
-        return min_entropy > entropy or 0 == min_entropy

credsweeper/filters/value_entropy_base_check.py

@@ -0,0 +1,37 @@
+from abc import abstractmethod
+
+from credsweeper.config import Config
+from credsweeper.credentials import LineData
+from credsweeper.file_handler.analysis_target import AnalysisTarget
+from credsweeper.filters import Filter
+from credsweeper.utils import Util
+
+
+class ValueEntropyBaseCheck(Filter):
+    """Check that candidate value has minimal Shanon Entropy for appropriated base"""
+
+    def __init__(self, config: Config = None) -> None:
+        pass
+
+    @staticmethod
+    @abstractmethod
+    def get_min_data_entropy(x: int) -> float:
+        """Returns minimal entropy for size of data"""
+        raise NotImplementedError()
+
+    def run(self, line_data: LineData, target: AnalysisTarget) -> bool:
+        """Run filter checks on received credential candidate data 'line_data'.
+
+        Args:
+            line_data: credential candidate data
+            target: multiline target from which line data was obtained
+
+        Return:
+            True, when need to filter candidate and False if left
+
+        """
+        entropy = Util.get_shannon_entropy(line_data.value)
+        min_entropy = self.get_min_data_entropy(len(line_data.value))
+        if min_entropy > entropy or 0 == min_entropy:
+            return True
+        return False

credsweeper/filters/value_file_path_check.py

@@ -53,7 +53,7 @@ class ValueFilePathCheck(Filter):
                     break
             else:
                 # all symbols are from base64 alphabet
-                entropy = Util.get_shannon_entropy(value, Chars.BASE64STDPAD_CHARS.value)
+                entropy = Util.get_shannon_entropy(value)
                 if 0 == min_entropy or min_entropy > entropy:
                     contains_unix_separator = 1 < value.count('/')
                 else:

credsweeper/filters/value_hex_number_check.py

@@ -7,9 +7,9 @@ from credsweeper.filters import Filter
 
 
 class ValueHexNumberCheck(Filter):
-    """Check value if it a value in 32 or 64 bits hex representation"""
+    """Check value if it is a value up to 64 bits hex representation"""
 
-    HEX_32_64_VALUE_REGEX = re.compile(r"^0x([0-9a-f]{8}){1,2}$")
+    HEX_08_64_VALUE_REGEX = re.compile(r"^0x[0-9a-f]{1,16}$")
 
     def __init__(self, config: Config = None) -> None:
         pass
@@ -26,6 +26,6 @@ class ValueHexNumberCheck(Filter):
 
         """
         value = line_data.value.lower()
-        if len(value) in [10, 18] and ValueHexNumberCheck.HEX_32_64_VALUE_REGEX.match(value):
+        if ValueHexNumberCheck.HEX_08_64_VALUE_REGEX.match(value):
             return True
         return False

credsweeper/filters/value_json_web_token_check.py

@@ -15,14 +15,13 @@ class ValueJsonWebTokenCheck(Filter):
     https://www.iana.org/assignments/jose/jose.xhtml
     """
     header_keys = {
-        "alg", "jku", "jwk", "kid", "x5u", "x5c", "x5t", "x5t#S256", "typ", "cty", "crit", "alg", "enc", "zip", "jku",
-        "jwk", "kid", "x5u", "x5c", "x5t", "x5t#S256", "typ", "cty", "crit", "epk", "apu", "apv", "iv", "tag", "p2s",
-        "p2c", "iss", "sub", "aud", "b64", "ppt", "url", "nonce", "svt"
+        "kid", "x5u", "x5t", "x5t#S256", "typ", "cty", "crit", "alg", "enc", "zip", "jku", "jwk", "x5c", "epk", "apu",
+        "apv", "iv", "tag", "p2s", "p2c", "iss", "sub", "aud", "b64", "ppt", "url", "nonce", "svt"
     }
     payload_keys = {
         "iss", "sub", "aud", "exp", "nbf", "iat", "jti", "kty", "use", "key_ops", "alg", "enc", "zip", "jku", "jwk",
-        "kid", "x5u", "x5c", "x5t", "x5t#S256", "crv", "x", "y", "d", "n", "e", "d", "p", "q", "dp", "dq", "qi", "oth",
-        "k", "crv", "d", "x", "ext", "crit", "keys", "id", "role", "token", "secret", "password", "nonce"
+        "kid", "x5u", "x5c", "x5t", "x5t#S256", "x", "y", "d", "n", "e", "p", "q", "dp", "dq", "qi", "oth", "k", "crv",
+        "ext", "crit", "keys", "id", "role", "token", "secret", "password", "nonce"
     }
 
     def __init__(self, config: Config = None) -> None:

credsweeper/filters/value_pattern_check.py

@@ -33,33 +33,33 @@ class ValuePatternCheck(Filter):
         # use non whitespace symbol pattern
         self.pattern = re.compile(fr"(\S)\1{{{str(self.pattern_len - 1)},}}")
 
-    def equal_pattern_check(self, line_data_value: str) -> bool:
+    def equal_pattern_check(self, value: str) -> bool:
         """Check if candidate value contain 4 and more same chars or numbers sequences.
 
         Args:
-            line_data_value: string variable, credential candidate value
+            value: string variable, credential candidate value
 
         Return:
             True if contain and False if not
 
         """
-        if self.pattern.findall(line_data_value):
+        if self.pattern.findall(value):
             return True
         return False
 
-    def ascending_pattern_check(self, line_data_value: str) -> bool:
+    def ascending_pattern_check(self, value: str) -> bool:
         """Check if candidate value contain 4 and more ascending chars or numbers sequences.
 
         Arg:
-            line_data_value: credential candidate value
+            value: credential candidate value
 
         Return:
             True if contain and False if not
 
         """
         count = 1
-        for key in range(len(line_data_value) - 1):
-            if ord(line_data_value[key + 1]) - ord(line_data_value[key]) == 1:
+        for key in range(len(value) - 1):
+            if ord(value[key + 1]) - ord(value[key]) == 1:
                 count += 1
             else:
                 count = 1
@@ -68,19 +68,19 @@ class ValuePatternCheck(Filter):
                 return True
         return False
 
-    def descending_pattern_check(self, line_data_value: str) -> bool:
+    def descending_pattern_check(self, value: str) -> bool:
         """Check if candidate value contain 4 and more descending chars or numbers sequences.
 
         Arg:
-            line_data_value: string variable, credential candidate value
+            value: string variable, credential candidate value
 
         Return:
             boolean variable. True if contain and False if not
 
         """
         count = 1
-        for key in range(len(line_data_value) - 1):
-            if ord(line_data_value[key]) - ord(line_data_value[key + 1]) == 1:
+        for key in range(len(value) - 1):
+            if ord(value[key]) - ord(value[key + 1]) == 1:
                 count += 1
             else:
                 count = 1
@@ -89,6 +89,57 @@ class ValuePatternCheck(Filter):
                 return True
         return False
 
+    def check_val(self, value: str) -> bool:
+        """Cumulative value check.
+
+        Arg:
+            value: string variable, credential candidate value
+
+        Return:
+            boolean variable. True if contain and False if not
+
+        """
+        if self.equal_pattern_check(value):
+            return True
+        if self.ascending_pattern_check(value):
+            return True
+        if self.descending_pattern_check(value):
+            return True
+        return False
+
+    def duple_pattern_check(self, value: str) -> bool:
+        """Check if candidate value is a duplet value with possible patterns.
+
+        Arg:
+            value: string variable, credential candidate value
+
+        Return:
+            boolean variable. True if contain and False if not
+
+        """
+        # 001122334455... case
+        pair_duple = True
+        # 0102030405... case
+        even_duple = True
+        even_prev = value[0]
+        even_value = value[0::2]
+        # 1020304050... case
+        odd_duple = True
+        odd_prev = value[1]
+        odd_value = value[1::2]
+        for even_i, odd_i in zip(even_value, odd_value):
+            pair_duple &= even_i == odd_i
+            even_duple &= even_i == even_prev
+            odd_duple &= odd_i == odd_prev
+            if not pair_duple and not even_duple and not odd_duple:
+                break
+        else:
+            if pair_duple or odd_duple:
+                return self.check_val(even_value)
+            if even_duple:
+                return self.check_val(odd_value)
+        return False
+
     def run(self, line_data: LineData, target: AnalysisTarget) -> bool:
         """Run filter checks on received credential candidate data 'line_data'.
 
@@ -103,13 +154,10 @@ class ValuePatternCheck(Filter):
         if len(line_data.value) < self.pattern_len:
             return True
 
-        if self.equal_pattern_check(line_data.value):
-            return True
-
-        if self.ascending_pattern_check(line_data.value):
+        if self.check_val(line_data.value):
             return True
 
-        if self.descending_pattern_check(line_data.value):
+        if 2 * self.pattern_len <= len(line_data.value) and self.duple_pattern_check(line_data.value):
             return True
 
         return False

credsweeper/filters/value_string_type_check.py

@@ -1,3 +1,5 @@
+import re
+
 from credsweeper.config import Config
 from credsweeper.credentials import LineData
 from credsweeper.file_handler.analysis_target import AnalysisTarget
@@ -9,6 +11,7 @@ class ValueStringTypeCheck(Filter):
 
     If it is, then checks if line_data really have string literal declaration.
     Comment rows in source files (start with //, /\*, etc) ignored.
+    Multiple bytes scenario allowed [123,23,54,67,78,89] or {0xae, 0x54, 0x55, 0xff}
 
     True if:
 
@@ -20,6 +23,8 @@ class ValueStringTypeCheck(Filter):
     False otherwise
     """
 
+    MULTIBYTE_PATTERN = re.compile(r"(\s*(0x)?[0-9a-f]{1,3}\s*,){8,80}", flags=re.IGNORECASE)
+
     def __init__(self, config: Config) -> None:
         self.check_for_literals = config.check_for_literals
 
@@ -37,10 +42,13 @@ class ValueStringTypeCheck(Filter):
         if not self.check_for_literals or line_data.url_part:
             return False
 
-        not_quoted = not line_data.is_well_quoted_value
-        not_comment = not line_data.is_comment()
+        if ValueStringTypeCheck.MULTIBYTE_PATTERN.match(line_data.value):
+            return False
 
-        if line_data.is_source_file_with_quotes() and not_comment and not_quoted and not line_data.is_quoted \
+        if line_data.is_source_file_with_quotes() \
+                and not line_data.is_comment() \
+                and not line_data.is_well_quoted_value \
+                and not line_data.is_quoted \
                 and line_data.separator and '=' in line_data.separator:
             # heterogeneous code e.g. YAML in Python uses colon sign instead equals
             return True

credsweeper/filters/value_token_base32_check.py

@@ -1,6 +1,5 @@
 from typing import Tuple
 
-from credsweeper.config import Config
 from credsweeper.filters.value_token_base_check import ValueTokenBaseCheck
 
 
@@ -21,9 +20,6 @@ class ValueTokenBase32Check(ValueTokenBaseCheck):
         64: ((3.4805990476190476, 0.28572156450556774), (2.035756800745673, 0.18815721535870078)),
     }
 
-    def __init__(self, config: Config = None) -> None:
-        super().__init__(config)
-
     @staticmethod
     def get_stat_range(size: int) -> Tuple[Tuple[float, float], Tuple[float, float]]:
         """Returns minimal, maximal for hop and deviation. Precalculated data is applied for speedup"""

credsweeper/filters/value_token_base36_check.py

@@ -1,6 +1,5 @@
 from typing import Tuple
 
-from credsweeper.config import Config
 from credsweeper.filters.value_token_base_check import ValueTokenBaseCheck
 
 
@@ -21,9 +20,6 @@ class ValueTokenBase36Check(ValueTokenBaseCheck):
         64: ((3.7190009761904763, 0.30325954360127116), (2.1751172797904093, 0.1942582237461476)),
     }
 
-    def __init__(self, config: Config = None) -> None:
-        super().__init__(config)
-
     @staticmethod
     def get_stat_range(size: int) -> Tuple[Tuple[float, float], Tuple[float, float]]:
         """Returns minimal, maximal for hop and deviation. Precalculated data is applied for speedup"""

credsweeper/filters/value_token_base64_check.py

@@ -1,6 +1,5 @@
 from typing import Tuple
 
-from credsweeper.config import Config
 from credsweeper.filters.value_token_base_check import ValueTokenBaseCheck
 
 
@@ -21,9 +20,6 @@ class ValueTokenBase64Check(ValueTokenBaseCheck):
         64: ((3.7625271746031745, 0.31733579704946846), (2.257532519514275, 0.20571908142867643)),
     }
 
-    def __init__(self, config: Config = None) -> None:
-        super().__init__(config)
-
     @staticmethod
     def get_stat_range(size: int) -> Tuple[Tuple[float, float], Tuple[float, float]]:
         """Returns minimal, maximal for hop and deviation. Precalculated data is applied for speedup"""