Merge 31df27ec3e into 7b3402b207

Adapted policy.py to newest dev version
Added allowed policy fields
2026-05-25 15:31:23 +02:00 · 2024-03-15 18:36:01 -04:00 · 2024-03-15 15:57:05 +01:00 · 2024-03-15 15:41:56 +01:00
43 changed files with 248 additions and 1810 deletions
@@ -18,7 +18,7 @@ jobs:
      - name: Install dependencies
        run: |
          python -m pip install --upgrade pip
-          pip install -U codecov coveralls flake8 mypy pylint pytest tox
+          pip install -U codecov coveralls flake8 mypy pylint pytest tox vulture
      - name: Run Tox
        run: |
          tox
@@ -48,22 +48,7 @@ usage: ssh-audit.py [options] <host>
   -c,  --client-audit     starts a server on port 2222 to audit client
                               software config (use -p to change port;
                               use -t to change timeout)
-        --conn-rate-test=N[:max_rate]  perform a connection rate test (useful
-                                       for collecting metrics related to
-                                       susceptibility of the DHEat vuln).
-                                       Testing is conducted with N concurrent
-                                       sockets with an optional maximum rate
-                                       of connections per second.
   -d,  --debug            Enable debug output.
-        --dheat=N[:kex[:e_len]]    continuously perform the DHEat DoS attack
-                                   (CVE-2002-20001) against the target using N
-                                   concurrent sockets.  Optionally, a specific
-                                   key exchange algorithm can be specified
-                                   instead of allowing it to be automatically
-                                   chosen.  Additionally, a small length of
-                                   the fake e value sent to the server can
-                                   be chosen for a more efficient attack (such
-                                   as 4).
   -g,  --gex-test=<x[,y,...]>  dh gex modulus size test
                   <min1:pref1:max1[,min2:pref2:max2,...]>
                   <x-y[:step]>
@@ -83,9 +68,6 @@ usage: ssh-audit.py [options] <host>
   -p,  --port=<port>      port to connect
   -P,  --policy=<"policy name" | policy.txt>  run a policy test using the
                                                   specified policy
-        --skip-rate-test   skip the connection rate test during standard audits
-                               (used to safely infer whether the DHEat attack
-                               is viable)
   -t,  --timeout=<secs>   timeout (in seconds) for connection and reading
                               (default: 5)
   -T,  --targets=<hosts.txt>  a file containing a list of target hosts (one
@@ -150,21 +132,6 @@ To create a policy based on a target server (which can be manually edited):
 ssh-audit -M new_policy.txt targetserver
 ```

-To run the DHEat CPU exhaustion DoS attack ([CVE-2002-20001](https://nvd.nist.gov/vuln/detail/CVE-2002-20001)) against a target using 10 concurrent sockets:
-```
-ssh-audit --dheat=10 targetserver
-```
-
-To run the DHEat attack using the `diffie-hellman-group-exchange-sha256` key exchange algorithm:
-```
-ssh-audit --dheat=10:diffie-hellman-group-exchange-sha256 targetserver
-```
-
-To run the DHEat attack using the `diffie-hellman-group-exchange-sha256` key exchange algorithm along with very small but non-standard packet lengths (this may result in the same CPU exhaustion, but with many less bytes per second being sent):
-```
-ssh-audit --dheat=10:diffie-hellman-group-exchange-sha256:4 targetserver
-```
-
 ## Screenshots

 ### Server Standard Audit Example
@@ -213,21 +180,17 @@ For convenience, a web front-end on top of the command-line tool is available at

 ## ChangeLog

-### v3.2.0 (2024-04-22)
- - Added implementation of the DHEat denial-of-service attack (see `--dheat` option; [CVE-2002-20001](https://nvd.nist.gov/vuln/detail/CVE-2002-20001)).
+### v3.2.0-dev (???)
 - Expanded filter of CBC ciphers to flag for the Terrapin vulnerability.  It now includes more rarely found ciphers.
+ - Color output is disabled if the `NO_COLOR` environment variable is set (see https://no-color.org/).
 - Fixed parsing of `ecdsa-sha2-nistp*` CA signatures on host keys.  Additionally, they are now flagged as potentially back-doored, just as standard host keys are.
 - Gracefully handle rare exceptions (i.e.: crashes) while performing GEX tests.
+ - Built-in policies now include a change log (use `-L -v` to view them).
+ - Added built-in policies for Amazon Linux 2023, Debian 12, OpenSSH 9.7, and Rocky Linux 9.
 - The built-in man page (`-m`, `--manual`) is now available on Docker, PyPI, and Snap builds, in addition to the Windows build.
 - Snap builds are now architecture-independent.
 - Changed Docker base image from `python:3-slim` to `python:3-alpine`, resulting in a 59% reduction in image size; credit [Daniel Thamdrup](https://github.com/dallemon).
- - Added built-in policies for Amazon Linux 2023, Debian 12, OpenSSH 9.7, and Rocky Linux 9.
- - Built-in policies now include a change log (use `-L -v` to view them).
- - Custom policies now support the `allow_algorithm_subset_and_reordering` directive to allow targets to pass with a subset and/or re-ordered list of host keys, kex, ciphers, and MACs.  This allows for the creation of a baseline policy where targets can optionally implement stricter controls; partial credit [yannik1015](https://github.com/yannik1015).
- - Custom policies now support the `allow_larger_keys` directive to allow targets to pass with larger host keys, CA keys, and Diffie-Hellman keys.  This allows for the creation of a baseline policy where targets can optionally implement stricter controls; partial credit [Damian Szuberski](https://github.com/szubersk).
- - Color output is disabled if the `NO_COLOR` environment variable is set (see https://no-color.org/).
 - Added 1 new key exchange algorithm: `gss-nistp384-sha384-*`.
- - Added 1 new cipher: `aes128-ocb@libassh.org`.

 ### v3.1.0 (2023-12-20)
 - Added test for the Terrapin message prefix truncation vulnerability ([CVE-2023-48795](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2023-48795)).
@@ -464,7 +464,7 @@ run_test() {
        exit 1
    fi

-    ./ssh-audit.py --skip-rate-test localhost:2222 > "$test_result_stdout"
+    ./ssh-audit.py localhost:2222 > "$test_result_stdout"
    actual_retval=$?
    if [[ $actual_retval != "$expected_retval" ]]; then
        echo -e "${REDB}Unexpected return value.  Expected: ${expected_retval}; Actual: ${actual_retval}${CLR}"
@@ -478,7 +478,7 @@ run_test() {
        exit 1
    fi

-    ./ssh-audit.py --skip-rate-test -jj localhost:2222 > "$test_result_json"
+    ./ssh-audit.py -jj localhost:2222 > "$test_result_json"
    actual_retval=$?
    if [[ $actual_retval != "$expected_retval" ]]; then
        echo -e "${REDB}Unexpected return value.  Expected: ${expected_retval}; Actual: ${actual_retval}${CLR}"
@@ -784,15 +784,6 @@ run_custom_policy_test "config2" "test13" "${PROGRAM_RETVAL_GOOD}"
 # Failing test with DH modulus test.
 run_custom_policy_test "config2" "test14" "${PROGRAM_RETVAL_FAILURE}"

-# Passing test with algorithm subset matching.
-run_custom_policy_test "config2" "test15" "${PROGRAM_RETVAL_GOOD}"
-
-# Failing test with algorithm subset matching.
-run_custom_policy_test "config2" "test16" "${PROGRAM_RETVAL_FAILURE}"
-
-# Passing test with larger key matching.
-run_custom_policy_test "config2" "test17" "${PROGRAM_RETVAL_GOOD}"
-
 # Failing test for built-in OpenSSH 8.0p1 server policy (RSA host key size is 3072 instead of 4096).
 run_builtin_policy_test "Hardened OpenSSH Server v8.0 (version 4)" "8.0p1" "test1" "-o HostKeyAlgorithms=rsa-sha2-512,rsa-sha2-256,ssh-ed25519 -o KexAlgorithms=curve25519-sha256,curve25519-sha256@libssh.org,diffie-hellman-group16-sha512,diffie-hellman-group18-sha512,diffie-hellman-group-exchange-sha256 -o Ciphers=chacha20-poly1305@openssh.com,aes256-gcm@openssh.com,aes128-gcm@openssh.com,aes256-ctr,aes192-ctr,aes128-ctr -o MACs=hmac-sha2-256-etm@openssh.com,hmac-sha2-512-etm@openssh.com,umac-128-etm@openssh.com" "${PROGRAM_RETVAL_FAILURE}"

@@ -1,7 +1,7 @@
 """
   The MIT License (MIT)

-   Copyright (C) 2017-2024 Joe Testa (jtesta@positronsecurity.com)
+   Copyright (C) 2017-2021 Joe Testa (jtesta@positronsecurity.com)
   Copyright (C) 2017 Andris Raugulis (moo@arthepsy.eu)

   Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -60,20 +60,10 @@ class AuditConf:
        self.manual = False
        self.debug = False
        self.gex_test = ''
-        self.dheat: Optional[str] = None
-        self.dheat_concurrent_connections: int = 0
-        self.dheat_e_length: int = 0
-        self.dheat_target_alg: str = ""
-        self.skip_rate_test = False
-        self.conn_rate_test: str = "1:1"
-        self.conn_rate_test_enabled = False
-        self.conn_rate_test_threads = 0
-        self.conn_rate_test_target_rate = 0
-

    def __setattr__(self, name: str, value: Union[str, int, float, bool, Sequence[int]]) -> None:
        valid = False
-        if name in ['batch', 'client_audit', 'colors', 'json', 'json_print_indent', 'list_policies', 'manual', 'make_policy', 'ssh1', 'ssh2', 'timeout_set', 'verbose', 'debug', 'skip_rate_test']:
+        if name in ['batch', 'client_audit', 'colors', 'json', 'json_print_indent', 'list_policies', 'manual', 'make_policy', 'ssh1', 'ssh2', 'timeout_set', 'verbose', 'debug']:
            valid, value = True, bool(value)
        elif name in ['ipv4', 'ipv6']:
            valid, value = True, bool(value)
@@ -104,89 +94,6 @@ class AuditConf:
            if num_threads < 1:
                raise ValueError('invalid number of threads: {}'.format(value))
            value = num_threads
-        elif name == "dheat":
-            # Valid values:
-            #   * None
-            #   * "10" (concurrent-connections)
-            #   * "10:diffie-hellman-group18-sha512" (concurrent-connections:target-alg)
-            #   * "10:diffie-hellman-group18-sha512:100" (concurrent-connections:target-alg:e-length)
-            valid = True
-            if value is not None:
-
-                def _parse_concurrent_connections(s: str) -> int:
-                    if Utils.parse_int(s) < 1:
-                        raise ValueError("number of concurrent connections must be 1 or greater: {}".format(s))
-                    return int(s)
-
-                def _parse_e_length(s: str) -> int:
-                    s_int = Utils.parse_int(s)
-                    if s_int < 2:
-                        raise ValueError("length of e must not be less than 2: {}".format(s))
-                    return s_int
-
-                def _parse_target_alg(s: str) -> str:
-                    if len(s) == 0:
-                        raise ValueError("target algorithm must not be the empty string.")
-                    return s
-
-                value = str(value)
-                fields = value.split(':')
-
-                self.dheat_concurrent_connections = _parse_concurrent_connections(fields[0])
-
-                # Parse the target algorithm if present.
-                if len(fields) >= 2:
-                    self.dheat_target_alg = _parse_target_alg(fields[1])
-
-                # Parse the length of e, if present.
-                if len(fields) == 3:
-                    self.dheat_e_length = _parse_e_length(fields[2])
-
-                if len(fields) > 3:
-                    raise ValueError("only three fields are expected instead of {}: {}".format(len(fields), value))
-
-        elif name in ["dheat_concurrent_connections", "dheat_e_length"]:
-            valid = True
-            if not isinstance(value, int):
-                valid = False
-
-        elif name == "dheat_target_alg":
-            valid = True
-            if not isinstance(value, str):
-                valid = False
-
-        elif name == "conn_rate_test":
-            # Valid values:
-            #   * "4" (run rate test with 4 threads)
-            #   * "4:100" (run rate test with 4 threads, targeting 100 connections/second)
-
-            error_msg = "valid format for {:s} is \"N\" or \"N:N\", where N is an integer.".format(name)
-            self.conn_rate_test_enabled = True
-            fields = str(value).split(":")
-
-            if len(fields) > 2 or len(fields) == 0:
-                raise ValueError(error_msg)
-            else:
-                self.conn_rate_test_threads = int(fields[0])
-                if self.conn_rate_test_threads < 1:
-                    raise ValueError("number of threads must be 1 or greater.")
-
-                self.conn_rate_test_target_rate = 0
-                if len(fields) == 2:
-                    self.conn_rate_test_target_rate = int(fields[1])
-                    if self.conn_rate_test_target_rate < 1:
-                        raise ValueError("rate target must be 1 or greater.")
-
-        elif name == "conn_rate_test_enabled":
-            valid = True
-            if not isinstance(value, bool):
-                valid = False
-
-        elif name in ["conn_rate_test_threads", "conn_rate_test_target_rate"]:
-            valid = True
-            if not isinstance(value, int):
-                valid = False
-

        if valid:
            object.__setattr__(self, name, value)
@@ -1,7 +1,7 @@
 """
   The MIT License (MIT)

-   Copyright (C) 2017-2024 Joe Testa (jtesta@positronsecurity.com)
+   Copyright (C) 2017-2023 Joe Testa (jtesta@positronsecurity.com)

   Permission is hereby granted, free of charge, to any person obtaining a copy
   of this software and associated documentation files (the "Software"), to deal
@@ -22,7 +22,7 @@
   THE SOFTWARE.
 """
 # The version to display.
-VERSION = 'v3.2.0'
+VERSION = 'v3.2.0-dev'

 # SSH software to impersonate
 SSH_HEADER = 'SSH-{0}-OpenSSH_8.2'
@@ -48,15 +48,16 @@ class Policy:
        self._compressions: Optional[List[str]] = None
        self._host_keys: Optional[List[str]] = None
        self._optional_host_keys: Optional[List[str]] = None
+        self._allowed_host_keys: Optional[List[str]] = None
        self._kex: Optional[List[str]] = None
+        self._allowed_kex: Optional[List[str]] = None
        self._ciphers: Optional[List[str]] = None
+        self._allowed_ciphers: Optional[List[str]] = None
        self._macs: Optional[List[str]] = None
+        self._allowed_macs: Optional[List[str]] = None
        self._hostkey_sizes: Optional[Dict[str, Dict[str, Union[int, str, bytes]]]] = None
        self._dh_modulus_sizes: Optional[Dict[str, int]] = None
        self._server_policy = True
-        self._allow_algorithm_subset_and_reordering = False
-        self._allow_larger_keys = False
-        self._errors: List[Any] = []

        self._name_and_version: str = ''

@@ -115,7 +116,7 @@ class Policy:
            key = key.strip()
            val = val.strip()

-            if key not in ['name', 'version', 'banner', 'compressions', 'host keys', 'optional host keys', 'key exchanges', 'ciphers', 'macs', 'client policy', 'host_key_sizes', 'dh_modulus_sizes', 'allow_algorithm_subset_and_reordering', 'allow_larger_keys'] and not key.startswith('hostkey_size_') and not key.startswith('cakey_size_') and not key.startswith('dh_modulus_size_'):
+            if key not in ['name', 'version', 'banner', 'compressions', 'host keys', 'optional host keys', 'allowed host keys', 'key exchanges', 'allowed key exchanges', 'ciphers', 'allowed ciphers', 'macs', 'allowed macs', 'client policy', 'host_key_sizes', 'dh_modulus_sizes'] and not key.startswith('hostkey_size_') and not key.startswith('cakey_size_') and not key.startswith('dh_modulus_size_'):
                raise ValueError("invalid field found in policy: %s" % line)

            if key in ['name', 'banner']:
@@ -138,7 +139,7 @@ class Policy:
            elif key == 'version':
                self._version = val

-            elif key in ['compressions', 'host keys', 'optional host keys', 'key exchanges', 'ciphers', 'macs']:
+            elif key in ['compressions', 'host keys', 'optional host keys', 'allowed host keys', 'key exchanges', 'allowed key exchanges', 'ciphers', 'allowed ciphers', 'macs', 'allowed macs']:
                try:
                    algs = val.split(',')
                except ValueError:
@@ -154,12 +155,20 @@ class Policy:
                    self._host_keys = algs
                elif key == 'optional host keys':
                    self._optional_host_keys = algs
+                elif key == 'allowed host keys':
+                    self._allowed_host_keys = algs           
                elif key == 'key exchanges':
                    self._kex = algs
+                elif key == 'allowed key exchanges':
+                    self._allowed_kex = algs
                elif key == 'ciphers':
                    self._ciphers = algs
+                elif key == 'allowed ciphers':
+                    self._allowed_ciphers = algs
                elif key == 'macs':
                    self._macs = algs
+                elif key == 'allowed macs':
+                    self._allowed_macs = algs

            elif key.startswith('hostkey_size_'):  # Old host key size format.
                print(Policy.WARNING_DEPRECATED_DIRECTIVES, file=self._warning_target)  # Warn the user that the policy file is using deprecated directives.
@@ -208,10 +217,7 @@ class Policy:

            elif key.startswith('client policy') and val.lower() == 'true':
                self._server_policy = False
-            elif key == 'allow_algorithm_subset_and_reordering' and val.lower() == 'true':
-                self._allow_algorithm_subset_and_reordering = True
-            elif key == 'allow_larger_keys' and val.lower() == 'true':
-                self._allow_larger_keys = True
+

        if self._name is None:
            raise ValueError('The policy does not have a name field.')
@@ -221,12 +227,15 @@ class Policy:
        self._name_and_version = "%s (version %s)" % (self._name, self._version)


-    def _append_error(self, mismatched_field: str, expected_required: Optional[List[str]], expected_optional: Optional[List[str]], actual: List[str]) -> None:
+    @staticmethod
+    def _append_error(errors: List[Any], mismatched_field: str, expected_required: Optional[List[str]], expected_allowed: Optional[List[str]], expected_optional: Optional[List[str]], actual: List[str]) -> None:
        if expected_required is None:
            expected_required = ['']
        if expected_optional is None:
            expected_optional = ['']
-        self._errors.append({'mismatched_field': mismatched_field, 'expected_required': expected_required, 'expected_optional': expected_optional, 'actual': actual})
+        if expected_allowed is None:
+            expected_allowed = ['']
+        errors.append({'mismatched_field': mismatched_field, 'expected_required': expected_required, 'expected_allowed': expected_allowed, 'expected_optional': expected_optional, 'actual': actual})


    def _normalize_hostkey_sizes(self) -> None:
@@ -299,12 +308,6 @@ name = "Custom Policy (based on %s on %s)"
 # The version of this policy (displayed in the output during scans).  Not parsed, and may be any value, including strings.
 version = 1

-# When false, host keys, kex, ciphers, and MAC lists must match exactly.  When true, the target host may support a subset of the specified algorithms and/or algorithms may appear in a different order; this feature is useful for specifying a baseline and allowing some hosts the option to implement stricter controls.
-allow_algorithm_subset_and_reordering = false
-
-# When false, host keys, CA keys, and Diffie-Hellman key sizes must exactly match what's specified in this policy.  When true, target systems are allowed to have larger keys; this feature is useful for specifying a baseline and allowing some hosts the option to implement stricter controls.
-allow_larger_keys = false
-
 # The banner that must match exactly.  Commented out to ignore banners, since minor variability in the banner is sometimes normal.
 # banner = "%s"

@@ -334,53 +337,57 @@ macs = %s
        '''Evaluates a server configuration against this policy.  Returns a tuple of a boolean (True if server adheres to policy) and an array of strings that holds error messages.'''

        ret = True
+        errors: List[Any] = []

        banner_str = str(banner)
        if (self._banner is not None) and (banner_str != self._banner):
            ret = False
-            self._append_error('Banner', [self._banner], None, [banner_str])
+            self._append_error(errors, 'Banner', [self._banner], None, None, [banner_str])

        # All subsequent tests require a valid kex, so end here if we don't have one.
        if kex is None:
-            error_list, error_str = self._get_errors()
-            return ret, error_list, error_str
+            return ret, errors, self._get_error_str(errors)

        if (self._compressions is not None) and (kex.server.compression != self._compressions):
            ret = False
-            self._append_error('Compression', self._compressions, None, kex.server.compression)
+            self._append_error(errors, 'Compression', self._compressions, None, None, kex.server.compression)

        # If a list of optional host keys was given in the policy, remove any of its entries from the list retrieved from the server.  This allows us to do an exact comparison with the expected list below.
        pruned_host_keys = kex.key_algorithms
        if self._optional_host_keys is not None:
            pruned_host_keys = [x for x in kex.key_algorithms if x not in self._optional_host_keys]

-        # Check host keys.
-        if self._host_keys is not None:
-            # If the policy allows subsets and re-ordered algorithms...
-            if self._allow_algorithm_subset_and_reordering:
-                for hostkey_t in kex.key_algorithms:
-                    if hostkey_t not in self._host_keys:
-                        ret = False
-                        self._append_error('Host keys', self._host_keys, self._optional_host_keys, kex.key_algorithms)
-                        break
-            # The policy requires exact matching of algorithms.
-            elif pruned_host_keys != self._host_keys:
-                ret = False
-                self._append_error('Host keys', self._host_keys, self._optional_host_keys, kex.key_algorithms)
        
-        # Check host key sizes.
+
+        # Checking Hostkeys
+        hostkey_error = False
+        if self._allowed_host_keys is not None:
+            for hostkey_t in kex.key_algorithms:
+                if hostkey_t not in self._allowed_host_keys:
+                    self._append_error(errors, 'Host keys', self._host_keys, self._allowed_host_keys, self._optional_host_keys, kex.key_algorithms)
+                    ret = False
+                    hostkey_error = True
+        
+        if self._host_keys is not None:
+            for hostkey_t in self._host_keys:
+                if hostkey_t not in kex.key_algorithms:
+                    ret = False
+                    if not hostkey_error:
+                        self._append_error(errors, 'Host keys', self._host_keys, None, self._optional_host_keys, kex.key_algorithms)
+
+        # Checking Host Key Sizes
+
        if self._hostkey_sizes is not None:
            hostkey_types = list(self._hostkey_sizes.keys())
            hostkey_types.sort()  # Sorted to make testing output repeatable.
            for hostkey_type in hostkey_types:
-                expected_hostkey_size = cast(int, self._hostkey_sizes[hostkey_type]['hostkey_size'])
+                expected_hostkey_size = self._hostkey_sizes[hostkey_type]['hostkey_size']
                server_host_keys = kex.host_keys()
                if hostkey_type in server_host_keys:
-                    actual_hostkey_size = cast(int, server_host_keys[hostkey_type]['hostkey_size'])
-                    if (self._allow_larger_keys and actual_hostkey_size < expected_hostkey_size) or \
-                       (not self._allow_larger_keys and actual_hostkey_size != expected_hostkey_size):
+                    actual_hostkey_size = server_host_keys[hostkey_type]['hostkey_size']
+                    if actual_hostkey_size != expected_hostkey_size:
                        ret = False
-                        self._append_error('Host key (%s) sizes' % hostkey_type, [str(expected_hostkey_size)], None, [str(actual_hostkey_size)])
+                        self._append_error(errors, 'Host key (%s) sizes' % hostkey_type, [str(expected_hostkey_size)], None, None, [str(actual_hostkey_size)])

                    # If we have expected CA signatures set, check them against what the server returned.
                    if self._hostkey_sizes is not None and len(cast(str, self._hostkey_sizes[hostkey_type]['ca_key_type'])) > 0 and cast(int, self._hostkey_sizes[hostkey_type]['ca_key_size']) > 0:
@@ -392,60 +399,62 @@ macs = %s
                        # Ensure that the CA signature type is what's expected (i.e.: the server doesn't have an RSA sig when we're expecting an ED25519 sig).
                        if actual_ca_key_type != expected_ca_key_type:
                            ret = False
-                            self._append_error('CA signature type', [expected_ca_key_type], None, [actual_ca_key_type])
+                            self._append_error(errors, 'CA signature type', [expected_ca_key_type], None, None, [actual_ca_key_type])
                        # Ensure that the actual and expected signature sizes match.
-                        elif (self._allow_larger_keys and actual_ca_key_size < expected_ca_key_size) or \
-                             (not self._allow_larger_keys and actual_ca_key_size != expected_ca_key_size):
+                        elif actual_ca_key_size != expected_ca_key_size:
                            ret = False
-                            self._append_error('CA signature size (%s)' % actual_ca_key_type, [str(expected_ca_key_size)], None, [str(actual_ca_key_size)])
+                            self._append_error(errors, 'CA signature size (%s)' % actual_ca_key_type, [str(expected_ca_key_size)], None, None, [str(actual_ca_key_size)])

-        # Check key exchanges.
-        if self._kex is not None:
-            # If the policy allows subsets and re-ordered algorithms...
-            if self._allow_algorithm_subset_and_reordering:
-                for kex_t in kex.kex_algorithms:
-                    if kex_t not in self._kex:
-                        ret = False
-                        self._append_error('Key exchanges', self._kex, None, kex.kex_algorithms)
-                        break
-                # If kex-strict-?-v00@openssh.com is in the policy (i.e. the Terrapin vulnerability countermeasure), then it must appear in the server's list, regardless of the "allow_algorithm_subset_and_reordering" flag.
-                if ('kex-strict-s-v00@openssh.com' in self._kex and 'kex-strict-s-v00@openssh.com' not in kex.kex_algorithms) or \
-                   ('kex-strict-c-v00@openssh.com' in self._kex and 'kex-strict-c-v00@openssh.com' not in kex.kex_algorithms):
+        # Checking KEX
+        kex_error = False
+        if self._allowed_kex is not None:
+            for kex_t in kex.kex_algorithms:
+                if kex_t not in self._allowed_kex:
+                    self._append_error(errors, 'Kex Exchanges', None, self._allowed_kex, None, kex.kex_algorithms)
                    ret = False
-                    self._append_error('Key exchanges', self._kex, None, kex.kex_algorithms)
+                    kex_error = True
+                    break
        
-            # The policy requires exact matching of algorithms.
-            elif kex.kex_algorithms != self._kex:
-                ret = False
-                self._append_error('Key exchanges', self._kex, None, kex.kex_algorithms)
+        if self._kex is not None:
+            for kex_t in self._kex:
+                if kex_t not in kex.kex_algorithms:
+                    ret = False
+                    if not kex_error:
+                        self._append_error(errors, 'Key exchanges', self._kex, None, None, kex.kex_algorithms)

        # Checking Ciphers
+        cipher_error = False
+        if self._allowed_ciphers is not None:
+            for cipher_t in kex.server.encryption:
+                if cipher_t not in self._allowed_ciphers:
+                    self._append_error(errors, 'Ciphers', self._ciphers, self._allowed_ciphers, None, kex.server.encryption)
+                    ret = False
+                    cipher_error = True
+                    break
+        
        if self._ciphers is not None:
-            # If the policy allows subsets and re-ordered algorithms...
-            if self._allow_algorithm_subset_and_reordering:
-                for cipher_t in kex.server.encryption:
-                    if cipher_t not in self._ciphers:
-                        ret = False
-                        self._append_error('Ciphers', self._ciphers, None, kex.server.encryption)
-                        break
-            # The policy requires exact matching of algorithms.
-            elif kex.server.encryption != self._ciphers:
-                ret = False
-                self._append_error('Ciphers', self._ciphers, None, kex.server.encryption)
+            for cipher_t in self._ciphers:
+                if cipher_t not in kex.server.encryption:
+                    ret = False
+                    if not cipher_error:
+                        self._append_error(errors, 'Ciphers', self._ciphers, None, None, kex.server.encryption)

        # Checking MACs
+        mac_error = False
+        if self._allowed_macs is not None:
+            for mac_t in kex.server.mac:
+                if mac_t not in self._allowed_macs:
+                    ret = False
+                    mac_error = True
+                    self._append_error(errors, 'MACs', self._macs, self._allowed_macs, None, kex.server.mac)
+                    break
+        
        if self._macs is not None:
-            # If the policy allows subsets and re-ordered algorithms...
-            if self._allow_algorithm_subset_and_reordering:
-                for mac_t in kex.server.mac:
-                    if mac_t not in self._macs:
-                        ret = False
-                        self._append_error('MACs', self._macs, None, kex.server.mac)
-                        break
-            # The policy requires exact matching of algorithms.
-            elif kex.server.mac != self._macs:
-                ret = False
-                self._append_error('MACs', self._macs, None, kex.server.mac)
+            for mac_t in self._macs:
+                if mac_t not in kex.server.mac:
+                    ret = False
+                    if not mac_error:
+                        self._append_error(errors, 'MACs', self._macs, None, None, kex.server.mac)

        if self._dh_modulus_sizes is not None:
            dh_modulus_types = list(self._dh_modulus_sizes.keys())
@@ -454,30 +463,34 @@ macs = %s
                expected_dh_modulus_size = self._dh_modulus_sizes[dh_modulus_type]
                if dh_modulus_type in kex.dh_modulus_sizes():
                    actual_dh_modulus_size = kex.dh_modulus_sizes()[dh_modulus_type]
-                    if (self._allow_larger_keys and actual_dh_modulus_size < expected_dh_modulus_size) or \
-                       (not self._allow_larger_keys and actual_dh_modulus_size != expected_dh_modulus_size):
+                    if expected_dh_modulus_size != actual_dh_modulus_size:
                        ret = False
-                        self._append_error('Group exchange (%s) modulus sizes' % dh_modulus_type, [str(expected_dh_modulus_size)], None, [str(actual_dh_modulus_size)])
+                        self._append_error(errors, 'Group exchange (%s) modulus sizes' % dh_modulus_type, [str(expected_dh_modulus_size)], None, [str(actual_dh_modulus_size)])

-        error_list, error_str = self._get_errors()
-        return ret, error_list, error_str
+        return ret, errors, self._get_error_str(errors)


-    def _get_errors(self) -> Tuple[List[Any], str]:
-        '''Returns the list of errors, along with the string representation of those errors.'''
+    @staticmethod
+    def _get_error_str(errors: List[Any]) -> str:
+        '''Transforms an error struct to a flat string of error messages.'''
       
-        subset_and_reordering_semicolon = "; subset and/or reordering allowed" if self._allow_algorithm_subset_and_reordering else "; exact match"
-        subset_and_reordering_parens = " (subset and/or reordering allowed)" if self._allow_algorithm_subset_and_reordering else ""
        error_list = []
        spacer = ''
-        for e in self._errors:
+        for e in errors:
            e_str = "  * %s did not match.\n" % e['mismatched_field']
            
-            if ('expected_optional' in e) and (e['expected_optional'] != ['']):
-                e_str += "    - Expected (required%s): %s\n    - Expected (optional): %s\n" % (subset_and_reordering_semicolon, Policy._normalize_error_field(e['expected_required']), Policy._normalize_error_field(e['expected_optional']))
+            if ('expected_optional' in e) and (e['expected_optional'] != ['']) \
+            and ('expected_allowed' in e) and (e['expected_allowed'] != ['']):
+                e_str += "    - Expected (required): %s\n    - Expected (allowed): %s\n    - Expected (optional): %s\n" % (Policy._normalize_error_field(e['expected_required']), Policy._normalize_error_field(e['expected_allowed']), Policy._normalize_error_field(e['expected_optional']))
+                spacer = '              '
+            elif ('expected_allowed' in e) and (e['expected_allowed'] != ['']):
+                e_str += "    - Expected (required): %s\n    - Expected (allowed):  %s\n" % (Policy._normalize_error_field(e['expected_required']), Policy._normalize_error_field(e['expected_allowed']))
+                spacer = '              '
+            elif ('expected_optional' in e) and (e['expected_optional'] != ['']):
+                e_str += "    - Expected (required): %s\n    - Expected (optional): %s\n" % (Policy._normalize_error_field(e['expected_required']), Policy._normalize_error_field(e['expected_optional']))
                spacer = '              '
            else:
-                e_str += "    - Expected%s: %s\n" % (subset_and_reordering_parens, Policy._normalize_error_field(e['expected_required']))
+                e_str += "    - Expected: %s\n" % Policy._normalize_error_field(e['expected_required'])
                spacer = '   '
            e_str += "    - Actual:%s%s\n" % (spacer, Policy._normalize_error_field(e['actual']))
            error_list.append(e_str)
@@ -488,7 +501,7 @@ macs = %s
        if len(error_list) > 0:
            error_str = "\n".join(error_list)

-        return self._errors, error_str
+        return error_str


    def get_name_and_version(self) -> str:
@@ -604,4 +617,4 @@ macs = %s
        if self._dh_modulus_sizes is not None:
            dh_modulus_sizes_str = str(self._dh_modulus_sizes)

-        return "Name: %s\nVersion: %s\nAllow Algorithm Subset and/or Reordering: %r\nBanner: %s\nCompressions: %s\nHost Keys: %s\nOptional Host Keys: %s\nKey Exchanges: %s\nCiphers: %s\nMACs: %s\nHost Key Sizes: %s\nDH Modulus Sizes: %s\nServer Policy: %r" % (name, version, self._allow_algorithm_subset_and_reordering, banner, compressions_str, host_keys_str, optional_host_keys_str, kex_str, ciphers_str, macs_str, hostkey_sizes_str, dh_modulus_sizes_str, self._server_policy)
+        return "Name: %s\nVersion: %s\nBanner: %s\nCompressions: %s\nHost Keys: %s\nOptional Host Keys: %s\nKey Exchanges: %s\nCiphers: %s\nMACs: %s\nHost Key Sizes: %s\nDH Modulus Sizes: %s\nServer Policy: %r" % (name, version, banner, compressions_str, host_keys_str, optional_host_keys_str, kex_str, ciphers_str, macs_str, hostkey_sizes_str, dh_modulus_sizes_str, self._server_policy)
@@ -1,7 +1,7 @@
 """
   The MIT License (MIT)

-   Copyright (C) 2017-2024 Joe Testa (jtesta@positronsecurity.com)
+   Copyright (C) 2017-2023 Joe Testa (jtesta@positronsecurity.com)
   Copyright (C) 2017 Andris Raugulis (moo@arthepsy.eu)

   Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -62,8 +62,7 @@ class SSH2_KexDB:  # pylint: disable=too-few-public-methods
    WARN_TAG_SIZE_96 = 'using small 96-bit tag size'

    INFO_DEFAULT_OPENSSH_CIPHER = 'default cipher since OpenSSH 6.9'
-    INFO_DEFAULT_OPENSSH_KEX_65_TO_73 = 'default key exchange from OpenSSH 6.5 to 7.3'
-    INFO_DEFAULT_OPENSSH_KEX_74_TO_89 = 'default key exchange from OpenSSH 7.4 to 8.9'
+    INFO_DEFAULT_OPENSSH_KEX_64_TO_89 = 'default key exchange from OpenSSH 6.4 to 8.9'
    INFO_DEFAULT_OPENSSH_KEX_90 = 'default key exchange since OpenSSH 9.0'
    INFO_DEPRECATED_IN_OPENSSH88 = 'deprecated in OpenSSH 8.8: https://www.openssh.com/txt/release-8.8'
    INFO_DISABLED_IN_DBEAR67 = 'disabled in Dropbear SSH 2015.67'
@@ -83,8 +82,8 @@ class SSH2_KexDB:  # pylint: disable=too-few-public-methods
        # Format: 'algorithm_name': [['version_first_appeared_in'], [reason_for_failure1, reason_for_failure2, ...], [warning1, warning2, ...], [info1, info2, ...]]
        'kex': {
            'Curve25519SHA256': [[]],
-            'curve25519-sha256': [['7.4,d2018.76'], [], [], [INFO_DEFAULT_OPENSSH_KEX_74_TO_89]],
-            'curve25519-sha256@libssh.org': [['6.4,d2013.62,l10.6.0'], [], [], [INFO_DEFAULT_OPENSSH_KEX_65_TO_73]],
+            'curve25519-sha256': [['7.4,d2018.76'], [], [], [INFO_DEFAULT_OPENSSH_KEX_64_TO_89]],
+            'curve25519-sha256@libssh.org': [['6.4,d2013.62,l10.6.0'], [], [], [INFO_DEFAULT_OPENSSH_KEX_64_TO_89]],
            'curve448-sha512': [[]],
            'curve448-sha512@libssh.org': [[]],
            'diffie-hellman-group14-sha1': [['3.9,d0.53,l10.6.0'], [FAIL_SHA1], [WARN_2048BIT_MODULUS]],
@@ -224,7 +223,7 @@ class SSH2_KexDB:  # pylint: disable=too-few-public-methods
            'null': [[], [FAIL_PLAINTEXT]],
            'pgp-sign-dss': [[], [FAIL_1024BIT_MODULUS]],
            'pgp-sign-rsa': [[], [FAIL_1024BIT_MODULUS]],
-            'rsa-sha2-256': [['7.2,d2020.79']],
+            'rsa-sha2-256': [['7.2']],
            'rsa-sha2-256-cert-v01@openssh.com': [['7.8']],
            'rsa-sha2-512': [['7.2']],
            'rsa-sha2-512-cert-v01@openssh.com': [['7.8']],
@@ -243,7 +242,7 @@ class SSH2_KexDB:  # pylint: disable=too-few-public-methods
            'ssh-dss-sha256@ssh.com': [[], [FAIL_1024BIT_MODULUS]],
            'ssh-dss-sha384@ssh.com': [[], [FAIL_1024BIT_MODULUS]],
            'ssh-dss-sha512@ssh.com': [[], [FAIL_1024BIT_MODULUS]],
-            'ssh-ed25519': [['6.5,d2020.79,l10.7.0']],
+            'ssh-ed25519': [['6.5,l10.7.0']],
            'ssh-ed25519-cert-v01@openssh.com': [['6.5']],
            'ssh-ed448': [[]],
            'ssh-ed448-cert-v01@openssh.com': [[], [], [], [INFO_NEVER_IMPLEMENTED_IN_OPENSSH]],
@@ -297,7 +296,6 @@ class SSH2_KexDB:  # pylint: disable=too-few-public-methods
            'aes128-ctr': [['3.7,d0.52,l10.4.1']],
            'aes128-gcm': [[]],
            'aes128-gcm@openssh.com': [['6.2']],
-            'aes128-ocb@libassh.org': [[], [], [WARN_CIPHER_MODE]],
            'aes192-cbc': [['2.3.0,l10.2', '6.6', None], [], [WARN_CIPHER_MODE]],
            'aes192-ctr': [['3.7,l10.4.1']],
            'aes192-gcm@openssh.com': [[], [], [], [INFO_NEVER_IMPLEMENTED_IN_OPENSSH]],
@@ -337,7 +335,7 @@ class SSH2_KexDB:  # pylint: disable=too-few-public-methods
            'cast128-ecb': [[], [FAIL_CAST], [WARN_CIPHER_MODE]],
            'cast128-ofb': [[], [FAIL_CAST], [WARN_CIPHER_MODE]],
            'chacha20-poly1305': [[], [], [], [INFO_DEFAULT_OPENSSH_CIPHER]],
-            'chacha20-poly1305@openssh.com': [['6.5,d2020.79'], [], [], [INFO_DEFAULT_OPENSSH_CIPHER]],
+            'chacha20-poly1305@openssh.com': [['6.5'], [], [], [INFO_DEFAULT_OPENSSH_CIPHER]],
            'crypticore128@ssh.com': [[], [FAIL_UNPROVEN]],
            'des-cbc': [[], [FAIL_DES], [WARN_CIPHER_MODE, WARN_BLOCK_SIZE]],
            'des-cfb': [[], [FAIL_DES], [WARN_CIPHER_MODE, WARN_BLOCK_SIZE]],
@@ -27,7 +27,6 @@ import concurrent.futures
 import copy
 import getopt
 import json
-import multiprocessing
 import os
 import re
 import sys
@@ -45,7 +44,6 @@ from ssh_audit.algorithm import Algorithm
 from ssh_audit.algorithms import Algorithms
 from ssh_audit.auditconf import AuditConf
 from ssh_audit.banner import Banner
-from ssh_audit.dheat import DHEat
 from ssh_audit import exitcodes
 from ssh_audit.fingerprint import Fingerprint
 from ssh_audit.gextest import GEXTest
@@ -98,22 +96,7 @@ def usage(uout: OutputBuffer, err: Optional[str] = None) -> None:
    uout.info('   -6,  --ipv6             enable IPv6 (order of precedence)')
    uout.info('   -b,  --batch            batch output')
    uout.info('   -c,  --client-audit     starts a server on port 2222 to audit client\n                               software config (use -p to change port;\n                               use -t to change timeout)')
-    uout.info('        --conn-rate-test=N[:max_rate]  perform a connection rate test (useful')
-    uout.info('                                       for collecting metrics related to')
-    uout.info('                                       susceptibility of the DHEat vuln).')
-    uout.info('                                       Testing is conducted with N concurrent')
-    uout.info('                                       sockets with an optional maximum rate')
-    uout.info('                                       of connections per second.')
    uout.info('   -d,  --debug            debug output')
-    uout.info('        --dheat=N[:kex[:e_len]]    continuously perform the DHEat DoS attack')
-    uout.info('                                   (CVE-2002-20001) against the target using N')
-    uout.info('                                   concurrent sockets.  Optionally, a specific')
-    uout.info('                                   key exchange algorithm can be specified')
-    uout.info('                                   instead of allowing it to be automatically')
-    uout.info('                                   chosen.  Additionally, a small length of')
-    uout.info('                                   the fake e value sent to the server can')
-    uout.info('                                   be chosen for a more efficient attack (such')
-    uout.info('                                   as 4).')
    uout.info('   -g,  --gex-test=<x[,y,...]>  dh gex modulus size test')
    uout.info('                   <min1:pref1:max1[,min2:pref2:max2,...]>')
    uout.info('                   <x-y[:step]>')
@@ -128,7 +111,6 @@ def usage(uout: OutputBuffer, err: Optional[str] = None) -> None:
    uout.info('                                  environment variable is set)')
    uout.info('   -p,  --port=<port>      port to connect')
    uout.info('   -P,  --policy=<policy.txt>  run a policy test using the specified policy')
-    uout.info('        --skip-rate-test   skip the connection rate test during standard audits\n                               (used to safely infer whether the DHEat attack\n                               is viable)')
    uout.info('   -t,  --timeout=<secs>   timeout (in seconds) for connection and reading\n                               (default: 5)')
    uout.info('   -T,  --targets=<hosts.txt>  a file containing a list of target hosts (one\n                                   per line, format HOST[:PORT]).  Use --threads\n                                   to control concurrent scans.')
    uout.info('        --threads=<threads>    number of threads to use when scanning multiple\n                                   targets (-T/--targets) (default: 32)')
@@ -448,7 +430,7 @@ def output_recommendations(out: OutputBuffer, algs: Algorithms, algorithm_recomm


 # Output additional information & notes.
-def output_info(out: OutputBuffer, software: Optional['Software'], client_audit: bool, any_problems: bool, is_json_output: bool, additional_notes: List[str]) -> None:
+def output_info(out: OutputBuffer, software: Optional['Software'], client_audit: bool, any_problems: bool, is_json_output: bool, additional_notes: str) -> None:
    with out:
        # Tell user that PuTTY cannot be hardened at the protocol-level.
        if client_audit and (software is not None) and (software.product == Product.PuTTY):
@@ -459,9 +441,8 @@ def output_info(out: OutputBuffer, software: Optional['Software'], client_audit:
            out.warn('(nfo) For hardening guides on common OSes, please see: <https://www.ssh-audit.com/hardening_guides.html>')

        # Add any additional notes.
-        for additional_note in additional_notes:
-            if len(additional_note) > 0:
-                out.warn("(nfo) %s" % additional_note)
+        if len(additional_notes) > 0:
+            out.warn("(nfo) %s" % additional_notes)

    if not out.is_section_empty() and not is_json_output:
        out.head('# additional info')
@@ -469,8 +450,8 @@ def output_info(out: OutputBuffer, software: Optional['Software'], client_audit:
        out.sep()


-def post_process_findings(banner: Optional[Banner], algs: Algorithms, client_audit: bool, dh_rate_test_notes: str) -> Tuple[List[str], List[str]]:
-    '''Perform post-processing on scan results before reporting them to the user.  Returns a list of algorithms that should not be recommended and a list of notes.'''
+def post_process_findings(banner: Optional[Banner], algs: Algorithms, client_audit: bool) -> Tuple[List[str], str]:
+    '''Perform post-processing on scan results before reporting them to the user.  Returns a list of algorithms that should not be recommended'''

    def _add_terrapin_warning(db: Dict[str, Dict[str, List[List[Optional[str]]]]], category: str, algorithm_name: str) -> None:
        '''Adds a warning regarding the Terrapin vulnerability for the specified algorithm.'''
@@ -609,24 +590,20 @@ def post_process_findings(banner: Optional[Banner], algs: Algorithms, client_aud
                _add_terrapin_warning(db, "mac", mac)

    # Return a note telling the user that, while this target is properly configured, if connected to a vulnerable peer, then a vulnerable connection is still possible.
-    additional_notes = []
+    notes = ""
    if len(algs_to_note) > 0:
-        additional_notes.append("Be aware that, while this target properly supports the strict key exchange method (via the kex-strict-?-v00@openssh.com marker) needed to protect against the Terrapin vulnerability (CVE-2023-48795), all peers must also support this feature as well, otherwise the vulnerability will still be present.  The following algorithms would allow an unpatched peer to create vulnerable SSH channels with this target: %s.  If any CBC ciphers are in this list, you may remove them while leaving the *-etm@openssh.com MACs in place; these MACs are fine while paired with non-CBC cipher types." % ", ".join(algs_to_note))
+        notes = "Be aware that, while this target properly supports the strict key exchange method (via the kex-strict-?-v00@openssh.com marker) needed to protect against the Terrapin vulnerability (CVE-2023-48795), all peers must also support this feature as well, otherwise the vulnerability will still be present.  The following algorithms would allow an unpatched peer to create vulnerable SSH channels with this target: %s.  If any CBC ciphers are in this list, you may remove them while leaving the *-etm@openssh.com MACs in place; these MACs are fine while paired with non-CBC cipher types." % ", ".join(algs_to_note)

    # Add the chacha ciphers, CBC ciphers, and ETM MACs to the recommendation suppression list if they are not enabled on the server.  That way they are not recommended to the user to enable if they were explicitly disabled to handle the Terrapin vulnerability.  However, they can still be recommended for disabling.
    algorithm_recommendation_suppress_list += _get_chacha_ciphers_not_enabled(db, algs)
    algorithm_recommendation_suppress_list += _get_cbc_ciphers_not_enabled(db, algs)
    algorithm_recommendation_suppress_list += _get_etm_macs_not_enabled(db, algs)

-    # Append any notes related to the DH rate test.
-    if len(dh_rate_test_notes) > 0:
-        additional_notes.append(dh_rate_test_notes)
-
-    return algorithm_recommendation_suppress_list, additional_notes
+    return algorithm_recommendation_suppress_list, notes


 # Returns a exitcodes.* flag to denote if any failures or warnings were encountered.
-def output(out: OutputBuffer, aconf: AuditConf, banner: Optional[Banner], header: List[str], client_host: Optional[str] = None, kex: Optional[SSH2_Kex] = None, pkm: Optional[SSH1_PublicKeyMessage] = None, print_target: bool = False, dh_rate_test_notes: str = "") -> int:
+def output(out: OutputBuffer, aconf: AuditConf, banner: Optional[Banner], header: List[str], client_host: Optional[str] = None, kex: Optional[SSH2_Kex] = None, pkm: Optional[SSH1_PublicKeyMessage] = None, print_target: bool = False) -> int:

    program_retval = exitcodes.GOOD
    client_audit = client_host is not None  # If set, this is a client audit.
@@ -634,7 +611,7 @@ def output(out: OutputBuffer, aconf: AuditConf, banner: Optional[Banner], header
    algs = Algorithms(pkm, kex)

    # Perform post-processing on the findings to make final adjustments before outputting the results.
-    algorithm_recommendation_suppress_list, additional_notes = post_process_findings(banner, algs, client_audit, dh_rate_test_notes)
+    algorithm_recommendation_suppress_list, additional_notes = post_process_findings(banner, algs, client_audit)

    with out:
        if print_target:
@@ -891,7 +868,7 @@ def process_commandline(out: OutputBuffer, args: List[str], usage_cb: Callable[.

    try:
        sopts = 'h1246M:p:P:jbcnvl:t:T:Lmdg:'
-        lopts = ['help', 'ssh1', 'ssh2', 'ipv4', 'ipv6', 'make-policy=', 'port=', 'policy=', 'json', 'batch', 'client-audit', 'no-colors', 'verbose', 'level=', 'timeout=', 'targets=', 'list-policies', 'lookup=', 'threads=', 'manual', 'debug', 'gex-test=', 'dheat=', 'skip-rate-test', 'conn-rate-test=']
+        lopts = ['help', 'ssh1', 'ssh2', 'ipv4', 'ipv6', 'make-policy=', 'port=', 'policy=', 'json', 'batch', 'client-audit', 'no-colors', 'verbose', 'level=', 'timeout=', 'targets=', 'list-policies', 'lookup=', 'threads=', 'manual', 'debug', 'gex-test=']
        opts, args = getopt.gnu_getopt(args, sopts, lopts)
    except getopt.GetoptError as err:
        usage_cb(out, str(err))
@@ -979,12 +956,6 @@ def process_commandline(out: OutputBuffer, args: List[str], usage_cb: Callable[.
                    usage_cb(out, '{} {} {} is not valid'.format(o, bits_left_bound, bits_right_bound))

            aconf.gex_test = a
-        elif o == '--dheat':
-            aconf.dheat = a
-        elif o == '--skip-rate-test':
-            aconf.skip_rate_test = True
-        elif o == '--conn-rate-test':
-            aconf.conn_rate_test = a


    if len(args) == 0 and aconf.client_audit is False and aconf.target_file is None and aconf.list_policies is False and aconf.lookup == '' and aconf.manual is False:
@@ -1068,7 +1039,7 @@ def process_commandline(out: OutputBuffer, args: List[str], usage_cb: Callable[.
    return aconf


-def build_struct(target_host: str, banner: Optional['Banner'], cves: List[Dict[str, Union[str, float]]], kex: Optional['SSH2_Kex'] = None, pkm: Optional['SSH1_PublicKeyMessage'] = None, client_host: Optional[str] = None, software: Optional[Software] = None, algorithms: Optional[Algorithms] = None, algorithm_recommendation_suppress_list: Optional[List[str]] = None, additional_notes: List[str] = []) -> Any:  # pylint: disable=dangerous-default-value
+def build_struct(target_host: str, banner: Optional['Banner'], cves: List[Dict[str, Union[str, float]]], kex: Optional['SSH2_Kex'] = None, pkm: Optional['SSH1_PublicKeyMessage'] = None, client_host: Optional[str] = None, software: Optional[Software] = None, algorithms: Optional[Algorithms] = None, algorithm_recommendation_suppress_list: Optional[List[str]] = None, additional_notes: str = "") -> Any:  # pylint: disable=too-many-arguments

    def fetch_notes(algorithm: str, alg_type: str) -> Dict[str, List[Optional[str]]]:
        '''Returns a dictionary containing the messages in the "fail", "warn", and "info" levels for this algorithm.'''
@@ -1236,8 +1207,8 @@ def build_struct(target_host: str, banner: Optional['Banner'], cves: List[Dict[s
    # Add in the recommendations.
    res['recommendations'] = get_algorithm_recommendations(algorithms, algorithm_recommendation_suppress_list, software, for_server=True)

-    # Add in the additional notes.
-    res['additional_notes'] = additional_notes
+    # Add in the additional notes.  Currently just one string, but in the future this may grow to multiple strings.  Hence, an array is needed to prevent future schema breakage.
+    res['additional_notes'] = [additional_notes]

    return res

@@ -1319,14 +1290,6 @@ def audit(out: OutputBuffer, aconf: AuditConf, sshv: Optional[int] = None, print
            out.fail("Failed to parse server's kex.  Stack trace:\n%s" % str(traceback.format_exc()))
            return exitcodes.CONNECTION_ERROR

-        if aconf.dheat is not None:
-            DHEat(out, aconf, banner, kex).run()
-            return exitcodes.GOOD
-        elif aconf.conn_rate_test_enabled:
-            DHEat.dh_rate_test(out, aconf, kex, 0, 0, 0)
-            return exitcodes.GOOD
-
-        dh_rate_test_notes = ""
        if aconf.client_audit is False:
            HostKeyTest.run(out, s, kex)
            if aconf.gex_test != '':
@@ -1334,16 +1297,9 @@ def audit(out: OutputBuffer, aconf: AuditConf, sshv: Optional[int] = None, print
            else:
                GEXTest.run(out, s, banner, kex)

-                # Skip the rate test if the user specified "--skip-rate-test".
-                if aconf.skip_rate_test:
-                    out.d("Skipping rate test due to --skip-rate-test option.")
-                else:
-                    # Try to open many TCP connections against the server if any Diffie-Hellman key exchanges are present; this tests potential vulnerability to the DHEat DOS attack.  Use 3 concurrent sockets over at most 1.5 seconds to open at most 38 connections (stops if 1.5 seconds elapse, or 38 connections are opened--whichever comes first).  If more than 25 connections per second were observed, flag the DH algorithms with a warning about the DHEat DOS vuln.
-                    dh_rate_test_notes = DHEat.dh_rate_test(out, aconf, kex, 1.5, 38, 3)
-
        # This is a standard audit scan.
        if (aconf.policy is None) and (aconf.make_policy is False):
-            program_retval = output(out, aconf, banner, header, client_host=s.client_host, kex=kex, print_target=print_target, dh_rate_test_notes=dh_rate_test_notes)
+            program_retval = output(out, aconf, banner, header, client_host=s.client_host, kex=kex, print_target=print_target)

        # This is a policy test.
        elif (aconf.policy is not None) and (aconf.make_policy is False):
@@ -1632,9 +1588,8 @@ def main() -> int:


 if __name__ == '__main__':  # pragma: nocover
-    multiprocessing.freeze_support()  # Needed for PyInstaller (Windows) builds.
-
    exit_code = exitcodes.GOOD
+
    try:
        exit_code = main()
    except Exception:
@@ -1,4 +1,4 @@
-.TH SSH-AUDIT 1 "April 18, 2024"
+.TH SSH-AUDIT 1 "March 14, 2024"
 .SH NAME
 \fBssh-audit\fP \- SSH server & client configuration auditor
 .SH SYNOPSIS
@@ -46,21 +46,11 @@ Enables grepable output.
 .br
 Starts a server on port 2222 to audit client software configuration.  Use -p/--port=<port> to change port and -t/--timeout=<secs> to change listen timeout.

-.TP
-.B     \-\-conn\-rate\-test=N[:max_rate]
-.br
-Performs a connection rate test (useful for collecting metrics related to susceptibility of the DHEat vulnerability [CVE-2002-20001]).  A successful connection is counted when the server returns a valid SSH banner.  Testing is conducted with N concurrent sockets with an optional maximum rate of connections per second.
-
 .TP
 .B -d, \-\-debug
 .br
 Enable debug output.

-.TP
-.B     \-\-dheat=N[:kex[:e_len]]
-.br
-Run the DHEat DoS attack (CVE-2002-20001) against the target server (which will consume all available CPU resources).  The number of concurrent sockets, N, needed to achieve this effect will be highly dependent on the CPU resources available on the target, as well as the latency between the source and target machines.  The key exchange is automatically chosen based on which would cause maximum effect, unless explicitly chosen in the second field.  Lastly, an (experimental) option allows the length in bytes of the fake e value sent to the server to be specified in the third field.  Normally, the length of e is roughly the length of the modulus of the Diffie-Hellman exchange (hence, an 8192-bit / 1024-byte value of e is sent in each connection when targeting the diffie-hellman-group18-sha512 algorithm).  Instead, it was observed that many SSH implementations accept small values, such as 4 bytes; this results in a much more network-efficient attack.
-
 .TP
 .B -g, \-\-gex-test=<x[,y,...] | min1:pref1:max1[,min2:pref2:max2,...] | x-y[:step]>
 .br
@@ -136,11 +126,6 @@ The TCP port to connect to when auditing a server, or the port to listen on when
 .br
 Runs a policy audit against a target using the specified policy (see \fBPOLICY AUDIT\fP section for detailed description of this mode of operation).  Combine with -c/--client-audit to audit a client configuration instead of a server.  Use -L/--list-policies to list all official, built-in policies for common systems.

-.TP
-.B     \-\-skip\-rate\-test
-.br
-Skips the connection rate test during standard audits.  By default, a few dozen TCP connections are created with the target host to see if connection throttling is implemented (this can safely infer whether the target is vulnerable to the DHEat attack; see CVE-2002-20001).
-
 .TP
 .B -t, \-\-timeout=<secs>
 .br
@@ -288,46 +273,6 @@ ssh-audit targetserver --gex-test=0-5120:1024
 .fi
 .RE

-.LP
-To run the DHEat DoS attack (monitor the target server's CPU usage to determine the optimal number of concurrent sockets):
-.RS
-.nf
-ssh-audit targetserver --dheat=10
-.fi
-.RE
-
-.LP
-To run the DHEat attack and manually target the diffie-hellman-group-exchange-sha256 algorithm:
-.RS
-.nf
-ssh-audit targetserver --dheat=10:diffie-hellman-group-exchange-sha256
-.fi
-.RE
-
-.LP
-To run the DHEat attack and manually target the diffie-hellman-group-exchange-sha256 algorithm with a very small length of e (resulting in the same effect but without having to send large packets):
-.RS
-.nf
-ssh-audit targetserver --dheat=10:diffie-hellman-group-exchange-sha256:4
-.fi
-.RE
-
-.LP
-To test the number of successful connections per second that can be created with the target using 8 parallel threads (useful for detecting whether connection throttling is implemented by the target):
-.RS
-.nf
-ssh-audit targetserver --conn-rate-test=8
-.fi
-.RE
-
-.LP
-To use 8 parallel threads to create up to 100 connections per second with the target (useful for understanding how much CPU load is caused on the target simply from handling new connections vs excess modular exponentiation when performing the DHEat attack):
-.RS
-.nf
-ssh-audit targetserver --conn-rate-test=8:100
-.fi
-.RE
-
 .SH RETURN VALUES
 When a successful connection is made and all algorithms are rated as "good", \fBssh-audit\fP returns 0.  Other possible return values are:

@@ -1,7 +1,6 @@
 #!/usr/bin/env python3
 """src/ssh_audit/ssh_audit.py wrapper for backwards compatibility"""

-import multiprocessing
 import sys
 import traceback
 from pathlib import Path
@@ -11,14 +10,12 @@ sys.path.insert(0, str(Path(__file__).resolve().parent / "src"))
 from ssh_audit.ssh_audit import main  # noqa: E402
 from ssh_audit import exitcodes  # noqa: E402

-if __name__ == "__main__":
-    multiprocessing.freeze_support()  # Needed for PyInstaller (Windows) builds.
+exit_code = exitcodes.GOOD

-    exit_code = exitcodes.GOOD
-    try:
-        exit_code = main()
-    except Exception:
-        exit_code = exitcodes.UNKNOWN_ERROR
-        print(traceback.format_exc())
+try:
+    exit_code = main()
+except Exception:
+    exit_code = exitcodes.UNKNOWN_ERROR
+    print(traceback.format_exc())

-    sys.exit(exit_code)
+sys.exit(exit_code)
@@ -73,7 +73,6 @@ class _VirtualSocket:
        self.rdata = []
        self.sdata = []
        self.errors = {}
-        self.blocking = False
        self.gsock = _VirtualGlobalSocket(self)

    def _check_err(self, method):
@@ -84,18 +83,12 @@ class _VirtualSocket:
    def connect(self, address):
        return self._connect(address, False)

-    def connect_ex(self, address):
-        return self.connect(address)
-
    def _connect(self, address, ret=True):
        self.peer_address = address
        self._connected = True
        self._check_err('connect')
        return self if ret else None

-    def setblocking(self, r: bool):
-        self.blocking = r
-
    def settimeout(self, timeout):
        self.timeout = timeout

@@ -1,5 +1,7 @@
 {
-    "additional_notes": [],
+    "additional_notes": [
+        ""
+    ],
    "banner": {
        "comments": null,
        "protocol": "2.0",
@@ -94,7 +96,7 @@
            "algorithm": "curve25519-sha256",
            "notes": {
                "info": [
-                    "default key exchange from OpenSSH 7.4 to 8.9",
+                    "default key exchange from OpenSSH 6.4 to 8.9",
                    "available since OpenSSH 7.4, Dropbear SSH 2018.76"
                ]
            }
@@ -103,7 +105,7 @@
            "algorithm": "curve25519-sha256@libssh.org",
            "notes": {
                "info": [
-                    "default key exchange from OpenSSH 6.5 to 7.3",
+                    "default key exchange from OpenSSH 6.4 to 8.9",
                    "available since OpenSSH 6.4, Dropbear SSH 2013.62"
                ]
            }
@@ -6,9 +6,9 @@

 [0;36m# key exchange algorithms[0m
 [0;32m(kex) curve25519-sha256              -- [info] available since OpenSSH 7.4, Dropbear SSH 2018.76[0m
-[0;32m                                     `- [info] default key exchange from OpenSSH 7.4 to 8.9[0m
+[0;32m                                     `- [info] default key exchange from OpenSSH 6.4 to 8.9[0m
 [0;32m(kex) curve25519-sha256@libssh.org   -- [info] available since OpenSSH 6.4, Dropbear SSH 2013.62[0m
-[0;32m                                     `- [info] default key exchange from OpenSSH 6.5 to 7.3[0m
+[0;32m                                     `- [info] default key exchange from OpenSSH 6.4 to 8.9[0m
 [0;31m(kex) ecdh-sha2-nistp521             -- [fail] using elliptic curves that are suspected as being backdoored by the U.S. National Security Agency[0m
                                     `- [info] available since OpenSSH 5.7, Dropbear SSH 2013.62
 [0;31m(kex) ecdh-sha2-nistp384             -- [fail] using elliptic curves that are suspected as being backdoored by the U.S. National Security Agency[0m
@@ -1,5 +1,7 @@
 {
-    "additional_notes": [],
+    "additional_notes": [
+        ""
+    ],
    "banner": {
        "comments": null,
        "protocol": "1.99",
@@ -1,5 +1,7 @@
 {
-    "additional_notes": [],
+    "additional_notes": [
+        ""
+    ],
    "banner": {
        "comments": null,
        "protocol": "2.0",
@@ -1,5 +1,7 @@
 {
-    "additional_notes": [],
+    "additional_notes": [
+        ""
+    ],
    "banner": {
        "comments": null,
        "protocol": "2.0",
@@ -1,5 +1,7 @@
 {
-    "additional_notes": [],
+    "additional_notes": [
+        ""
+    ],
    "banner": {
        "comments": null,
        "protocol": "2.0",
@@ -1,5 +1,7 @@
 {
-    "additional_notes": [],
+    "additional_notes": [
+        ""
+    ],
    "banner": {
        "comments": null,
        "protocol": "2.0",
@@ -1,5 +1,7 @@
 {
-    "additional_notes": [],
+    "additional_notes": [
+        ""
+    ],
    "banner": {
        "comments": null,
        "protocol": "2.0",
@@ -1,6 +0,0 @@
-{
-    "errors": [],
-    "host": "localhost",
-    "passed": true,
-    "policy": "Docker policy: test15 (version 1)"
-}
@@ -1,3 +0,0 @@
-Host:   localhost:2222
-Policy: Docker policy: test15 (version 1)
-Result: [0;32m✔ Passed[0m
@@ -1,86 +0,0 @@
-{
-    "errors": [
-        {
-            "actual": [
-                "rsa-sha2-512",
-                "rsa-sha2-256",
-                "ssh-rsa",
-                "ecdsa-sha2-nistp256",
-                "ssh-ed25519"
-            ],
-            "expected_optional": [
-                ""
-            ],
-            "expected_required": [
-                "rsa-sha2-512",
-                "extra_hostkey_alg"
-            ],
-            "mismatched_field": "Host keys"
-        },
-        {
-            "actual": [
-                "curve25519-sha256",
-                "curve25519-sha256@libssh.org",
-                "ecdh-sha2-nistp256",
-                "ecdh-sha2-nistp384",
-                "ecdh-sha2-nistp521",
-                "diffie-hellman-group-exchange-sha256",
-                "diffie-hellman-group16-sha512",
-                "diffie-hellman-group18-sha512",
-                "diffie-hellman-group14-sha256",
-                "diffie-hellman-group14-sha1"
-            ],
-            "expected_optional": [
-                ""
-            ],
-            "expected_required": [
-                "curve25519-sha256",
-                "extra_kex_alg"
-            ],
-            "mismatched_field": "Key exchanges"
-        },
-        {
-            "actual": [
-                "chacha20-poly1305@openssh.com",
-                "aes128-ctr",
-                "aes192-ctr",
-                "aes256-ctr",
-                "aes128-gcm@openssh.com",
-                "aes256-gcm@openssh.com"
-            ],
-            "expected_optional": [
-                ""
-            ],
-            "expected_required": [
-                "chacha20-poly1305@openssh.com",
-                "extra_cipher_alg"
-            ],
-            "mismatched_field": "Ciphers"
-        },
-        {
-            "actual": [
-                "umac-64-etm@openssh.com",
-                "umac-128-etm@openssh.com",
-                "hmac-sha2-256-etm@openssh.com",
-                "hmac-sha2-512-etm@openssh.com",
-                "hmac-sha1-etm@openssh.com",
-                "umac-64@openssh.com",
-                "umac-128@openssh.com",
-                "hmac-sha2-256",
-                "hmac-sha2-512",
-                "hmac-sha1"
-            ],
-            "expected_optional": [
-                ""
-            ],
-            "expected_required": [
-                "umac-64-etm@openssh.com",
-                "extra_mac_alg"
-            ],
-            "mismatched_field": "MACs"
-        }
-    ],
-    "host": "localhost",
-    "passed": false,
-    "policy": "Docker policy: test16 (version 1)"
-}
@@ -1,21 +0,0 @@
-Host:   localhost:2222
-Policy: Docker policy: test16 (version 1)
-Result: [0;31m❌ Failed![0m
-[0;33m
-Errors:
-  * Ciphers did not match.
-    - Expected (subset and/or reordering allowed): chacha20-poly1305@openssh.com, extra_cipher_alg
-    - Actual:   chacha20-poly1305@openssh.com, aes128-ctr, aes192-ctr, aes256-ctr, aes128-gcm@openssh.com, aes256-gcm@openssh.com
-
-  * Host keys did not match.
-    - Expected (subset and/or reordering allowed): rsa-sha2-512, extra_hostkey_alg
-    - Actual:   rsa-sha2-512, rsa-sha2-256, ssh-rsa, ecdsa-sha2-nistp256, ssh-ed25519
-
-  * Key exchanges did not match.
-    - Expected (subset and/or reordering allowed): curve25519-sha256, extra_kex_alg
-    - Actual:   curve25519-sha256, curve25519-sha256@libssh.org, ecdh-sha2-nistp256, ecdh-sha2-nistp384, ecdh-sha2-nistp521, diffie-hellman-group-exchange-sha256, diffie-hellman-group16-sha512, diffie-hellman-group18-sha512, diffie-hellman-group14-sha256, diffie-hellman-group14-sha1
-
-  * MACs did not match.
-    - Expected (subset and/or reordering allowed): umac-64-etm@openssh.com, extra_mac_alg
-    - Actual:   umac-64-etm@openssh.com, umac-128-etm@openssh.com, hmac-sha2-256-etm@openssh.com, hmac-sha2-512-etm@openssh.com, hmac-sha1-etm@openssh.com, umac-64@openssh.com, umac-128@openssh.com, hmac-sha2-256, hmac-sha2-512, hmac-sha1
-[0m
@@ -1,6 +0,0 @@
-{
-    "errors": [],
-    "host": "localhost",
-    "passed": true,
-    "policy": "Docker policy: test17 (version 1)"
-}
@@ -1,3 +0,0 @@
-Host:   localhost:2222
-Policy: Docker policy: test17 (version 1)
-Result: [0;32m✔ Passed[0m
@@ -1,5 +1,7 @@
 {
-    "additional_notes": [],
+    "additional_notes": [
+        ""
+    ],
    "banner": {
        "comments": null,
        "protocol": "2.0",
@@ -38,7 +40,7 @@
            "notes": {
                "info": [
                    "default cipher since OpenSSH 6.9",
-                    "available since OpenSSH 6.5, Dropbear SSH 2020.79"
+                    "available since OpenSSH 6.5"
                ],
                "warn": [
                    "vulnerable to the Terrapin attack (CVE-2023-48795), allowing message prefix truncation"
@@ -113,7 +115,7 @@
            "algorithm": "curve25519-sha256",
            "notes": {
                "info": [
-                    "default key exchange from OpenSSH 7.4 to 8.9",
+                    "default key exchange from OpenSSH 6.4 to 8.9",
                    "available since OpenSSH 7.4, Dropbear SSH 2018.76"
                ]
            }
@@ -122,7 +124,7 @@
            "algorithm": "curve25519-sha256@libssh.org",
            "notes": {
                "info": [
-                    "default key exchange from OpenSSH 6.5 to 7.3",
+                    "default key exchange from OpenSSH 6.4 to 8.9",
                    "available since OpenSSH 6.4, Dropbear SSH 2013.62"
                ]
            }
@@ -227,7 +229,7 @@
            "keysize": 3072,
            "notes": {
                "info": [
-                    "available since OpenSSH 7.2, Dropbear SSH 2020.79"
+                    "available since OpenSSH 7.2"
                ]
            }
        },
@@ -262,7 +264,7 @@
            "algorithm": "ssh-ed25519",
            "notes": {
                "info": [
-                    "available since OpenSSH 6.5, Dropbear SSH 2020.79"
+                    "available since OpenSSH 6.5"
                ]
            }
        }
@@ -1,7 +1,7 @@
 [0;36m# general[0m
 [0;32m(gen) banner: SSH-2.0-OpenSSH_8.0[0m
 [0;32m(gen) software: OpenSSH 8.0[0m
-[0;32m(gen) compatibility: OpenSSH 7.4+, Dropbear SSH 2020.79+[0m
+[0;32m(gen) compatibility: OpenSSH 7.4+, Dropbear SSH 2018.76+[0m
 [0;32m(gen) compression: enabled (zlib@openssh.com)[0m

 [0;36m# security[0m
@@ -12,9 +12,9 @@

 [0;36m# key exchange algorithms[0m
 [0;32m(kex) curve25519-sha256                     -- [info] available since OpenSSH 7.4, Dropbear SSH 2018.76[0m
-[0;32m                                            `- [info] default key exchange from OpenSSH 7.4 to 8.9[0m
+[0;32m                                            `- [info] default key exchange from OpenSSH 6.4 to 8.9[0m
 [0;32m(kex) curve25519-sha256@libssh.org          -- [info] available since OpenSSH 6.4, Dropbear SSH 2013.62[0m
-[0;32m                                            `- [info] default key exchange from OpenSSH 6.5 to 7.3[0m
+[0;32m                                            `- [info] default key exchange from OpenSSH 6.4 to 8.9[0m
 [0;31m(kex) ecdh-sha2-nistp256                    -- [fail] using elliptic curves that are suspected as being backdoored by the U.S. National Security Agency[0m
                                            `- [info] available since OpenSSH 5.7, Dropbear SSH 2013.62
 [0;31m(kex) ecdh-sha2-nistp384                    -- [fail] using elliptic curves that are suspected as being backdoored by the U.S. National Security Agency[0m
@@ -33,18 +33,18 @@

 [0;36m# host-key algorithms[0m
 [0;32m(key) rsa-sha2-512 (3072-bit)               -- [info] available since OpenSSH 7.2[0m
-[0;32m(key) rsa-sha2-256 (3072-bit)               -- [info] available since OpenSSH 7.2, Dropbear SSH 2020.79[0m
+[0;32m(key) rsa-sha2-256 (3072-bit)               -- [info] available since OpenSSH 7.2[0m
 [0;31m(key) ssh-rsa (3072-bit)                    -- [fail] using broken SHA-1 hash algorithm[0m
                                            `- [info] available since OpenSSH 2.5.0, Dropbear SSH 0.28
                                            `- [info] deprecated in OpenSSH 8.8: https://www.openssh.com/txt/release-8.8
 [0;31m(key) ecdsa-sha2-nistp256                   -- [fail] using elliptic curves that are suspected as being backdoored by the U.S. National Security Agency[0m
 [0;33m                                            `- [warn] using weak random number generator could reveal the key[0m
                                            `- [info] available since OpenSSH 5.7, Dropbear SSH 2013.62
-[0;32m(key) ssh-ed25519                           -- [info] available since OpenSSH 6.5, Dropbear SSH 2020.79[0m
+[0;32m(key) ssh-ed25519                           -- [info] available since OpenSSH 6.5[0m

 [0;36m# encryption algorithms (ciphers)[0m
 [0;33m(enc) chacha20-poly1305@openssh.com         -- [warn] vulnerable to the Terrapin attack (CVE-2023-48795), allowing message prefix truncation[0m
-                                            `- [info] available since OpenSSH 6.5, Dropbear SSH 2020.79
+                                            `- [info] available since OpenSSH 6.5
                                            `- [info] default cipher since OpenSSH 6.9
 [0;32m(enc) aes128-ctr                            -- [info] available since OpenSSH 3.7, Dropbear SSH 0.52[0m
 [0;32m(enc) aes192-ctr                            -- [info] available since OpenSSH 3.7[0m
@@ -1,5 +1,7 @@
 {
-    "additional_notes": [],
+    "additional_notes": [
+        ""
+    ],
    "banner": {
        "comments": null,
        "protocol": "2.0",
@@ -38,7 +40,7 @@
            "notes": {
                "info": [
                    "default cipher since OpenSSH 6.9",
-                    "available since OpenSSH 6.5, Dropbear SSH 2020.79"
+                    "available since OpenSSH 6.5"
                ],
                "warn": [
                    "vulnerable to the Terrapin attack (CVE-2023-48795), allowing message prefix truncation"
@@ -103,7 +105,7 @@
            "algorithm": "curve25519-sha256",
            "notes": {
                "info": [
-                    "default key exchange from OpenSSH 7.4 to 8.9",
+                    "default key exchange from OpenSSH 6.4 to 8.9",
                    "available since OpenSSH 7.4, Dropbear SSH 2018.76"
                ]
            }
@@ -112,7 +114,7 @@
            "algorithm": "curve25519-sha256@libssh.org",
            "notes": {
                "info": [
-                    "default key exchange from OpenSSH 6.5 to 7.3",
+                    "default key exchange from OpenSSH 6.4 to 8.9",
                    "available since OpenSSH 6.4, Dropbear SSH 2013.62"
                ]
            }
@@ -207,7 +209,7 @@
            "algorithm": "ssh-ed25519",
            "notes": {
                "info": [
-                    "available since OpenSSH 6.5, Dropbear SSH 2020.79"
+                    "available since OpenSSH 6.5"
                ]
            }
        },
@@ -1,7 +1,7 @@
 [0;36m# general[0m
 [0;32m(gen) banner: SSH-2.0-OpenSSH_8.0[0m
 [0;32m(gen) software: OpenSSH 8.0[0m
-[0;32m(gen) compatibility: OpenSSH 7.4+, Dropbear SSH 2020.79+[0m
+[0;32m(gen) compatibility: OpenSSH 7.4+, Dropbear SSH 2018.76+[0m
 [0;32m(gen) compression: enabled (zlib@openssh.com)[0m

 [0;36m# security[0m
@@ -12,9 +12,9 @@

 [0;36m# key exchange algorithms[0m
 [0;32m(kex) curve25519-sha256                     -- [info] available since OpenSSH 7.4, Dropbear SSH 2018.76[0m
-[0;32m                                            `- [info] default key exchange from OpenSSH 7.4 to 8.9[0m
+[0;32m                                            `- [info] default key exchange from OpenSSH 6.4 to 8.9[0m
 [0;32m(kex) curve25519-sha256@libssh.org          -- [info] available since OpenSSH 6.4, Dropbear SSH 2013.62[0m
-[0;32m                                            `- [info] default key exchange from OpenSSH 6.5 to 7.3[0m
+[0;32m                                            `- [info] default key exchange from OpenSSH 6.4 to 8.9[0m
 [0;31m(kex) ecdh-sha2-nistp256                    -- [fail] using elliptic curves that are suspected as being backdoored by the U.S. National Security Agency[0m
                                            `- [info] available since OpenSSH 5.7, Dropbear SSH 2013.62
 [0;31m(kex) ecdh-sha2-nistp384                    -- [fail] using elliptic curves that are suspected as being backdoored by the U.S. National Security Agency[0m
@@ -32,12 +32,12 @@
                                            `- [info] available since OpenSSH 3.9, Dropbear SSH 0.53

 [0;36m# host-key algorithms[0m
-[0;32m(key) ssh-ed25519                           -- [info] available since OpenSSH 6.5, Dropbear SSH 2020.79[0m
+[0;32m(key) ssh-ed25519                           -- [info] available since OpenSSH 6.5[0m
 [0;32m(key) ssh-ed25519-cert-v01@openssh.com (256-bit cert/256-bit ssh-ed25519 CA) -- [info] available since OpenSSH 6.5[0m

 [0;36m# encryption algorithms (ciphers)[0m
 [0;33m(enc) chacha20-poly1305@openssh.com         -- [warn] vulnerable to the Terrapin attack (CVE-2023-48795), allowing message prefix truncation[0m
-                                            `- [info] available since OpenSSH 6.5, Dropbear SSH 2020.79
+                                            `- [info] available since OpenSSH 6.5
                                            `- [info] default cipher since OpenSSH 6.9
 [0;32m(enc) aes128-ctr                            -- [info] available since OpenSSH 3.7, Dropbear SSH 0.52[0m
 [0;32m(enc) aes192-ctr                            -- [info] available since OpenSSH 3.7[0m
@@ -1,5 +1,7 @@
 {
-    "additional_notes": [],
+    "additional_notes": [
+        ""
+    ],
    "banner": {
        "comments": null,
        "protocol": "2.0",
@@ -38,7 +40,7 @@
            "notes": {
                "info": [
                    "default cipher since OpenSSH 6.9",
-                    "available since OpenSSH 6.5, Dropbear SSH 2020.79"
+                    "available since OpenSSH 6.5"
                ],
                "warn": [
                    "vulnerable to the Terrapin attack (CVE-2023-48795), allowing message prefix truncation"
@@ -103,7 +105,7 @@
            "algorithm": "curve25519-sha256",
            "notes": {
                "info": [
-                    "default key exchange from OpenSSH 7.4 to 8.9",
+                    "default key exchange from OpenSSH 6.4 to 8.9",
                    "available since OpenSSH 7.4, Dropbear SSH 2018.76"
                ]
            }
@@ -112,7 +114,7 @@
            "algorithm": "curve25519-sha256@libssh.org",
            "notes": {
                "info": [
-                    "default key exchange from OpenSSH 6.5 to 7.3",
+                    "default key exchange from OpenSSH 6.4 to 8.9",
                    "available since OpenSSH 6.4, Dropbear SSH 2013.62"
                ]
            }
@@ -133,7 +135,7 @@
            "algorithm": "ssh-ed25519",
            "notes": {
                "info": [
-                    "available since OpenSSH 6.5, Dropbear SSH 2020.79"
+                    "available since OpenSSH 6.5"
                ]
            }
        }
@@ -1,7 +1,7 @@
 [0;36m# general[0m
 [0;32m(gen) banner: SSH-2.0-OpenSSH_8.0[0m
 [0;32m(gen) software: OpenSSH 8.0[0m
-[0;32m(gen) compatibility: OpenSSH 7.4+, Dropbear SSH 2020.79+[0m
+[0;32m(gen) compatibility: OpenSSH 7.4+, Dropbear SSH 2018.76+[0m
 [0;32m(gen) compression: enabled (zlib@openssh.com)[0m

 [0;36m# security[0m
@@ -12,18 +12,18 @@

 [0;36m# key exchange algorithms[0m
 [0;32m(kex) curve25519-sha256                     -- [info] available since OpenSSH 7.4, Dropbear SSH 2018.76[0m
-[0;32m                                            `- [info] default key exchange from OpenSSH 7.4 to 8.9[0m
+[0;32m                                            `- [info] default key exchange from OpenSSH 6.4 to 8.9[0m
 [0;32m(kex) curve25519-sha256@libssh.org          -- [info] available since OpenSSH 6.4, Dropbear SSH 2013.62[0m
-[0;32m                                            `- [info] default key exchange from OpenSSH 6.5 to 7.3[0m
+[0;32m                                            `- [info] default key exchange from OpenSSH 6.4 to 8.9[0m
 [0;32m(kex) diffie-hellman-group-exchange-sha256 (4096-bit) -- [info] available since OpenSSH 4.4[0m
 [0;32m                                                      `- [info] OpenSSH's GEX fallback mechanism was triggered during testing. Very old SSH clients will still be able to create connections using a 2048-bit modulus, though modern clients will use 4096. This can only be disabled by recompiling the code (see https://github.com/openssh/openssh-portable/blob/V_9_4/dh.c#L477).[0m

 [0;36m# host-key algorithms[0m
-[0;32m(key) ssh-ed25519                           -- [info] available since OpenSSH 6.5, Dropbear SSH 2020.79[0m
+[0;32m(key) ssh-ed25519                           -- [info] available since OpenSSH 6.5[0m

 [0;36m# encryption algorithms (ciphers)[0m
 [0;33m(enc) chacha20-poly1305@openssh.com         -- [warn] vulnerable to the Terrapin attack (CVE-2023-48795), allowing message prefix truncation[0m
-                                            `- [info] available since OpenSSH 6.5, Dropbear SSH 2020.79
+                                            `- [info] available since OpenSSH 6.5
                                            `- [info] default cipher since OpenSSH 6.9
 [0;32m(enc) aes256-gcm@openssh.com                -- [info] available since OpenSSH 6.2[0m
 [0;32m(enc) aes128-gcm@openssh.com                -- [info] available since OpenSSH 6.2[0m
@@ -1,5 +1,7 @@
 {
-    "additional_notes": [],
+    "additional_notes": [
+        ""
+    ],
    "banner": {
        "comments": "",
        "protocol": "2.0",
@@ -16,7 +18,7 @@
            "notes": {
                "info": [
                    "default cipher since OpenSSH 6.9",
-                    "available since OpenSSH 6.5, Dropbear SSH 2020.79"
+                    "available since OpenSSH 6.5"
                ],
                "warn": [
                    "vulnerable to the Terrapin attack (CVE-2023-48795), allowing message prefix truncation"
@@ -41,7 +43,7 @@
            "algorithm": "curve25519-sha256",
            "notes": {
                "info": [
-                    "default key exchange from OpenSSH 7.4 to 8.9",
+                    "default key exchange from OpenSSH 6.4 to 8.9",
                    "available since OpenSSH 7.4, Dropbear SSH 2018.76"
                ]
            }
@@ -50,7 +52,7 @@
            "algorithm": "curve25519-sha256@libssh.org",
            "notes": {
                "info": [
-                    "default key exchange from OpenSSH 6.5 to 7.3",
+                    "default key exchange from OpenSSH 6.4 to 8.9",
                    "available since OpenSSH 6.4, Dropbear SSH 2013.62"
                ]
            }
@@ -73,7 +75,7 @@
            "algorithm": "ssh-ed25519",
            "notes": {
                "info": [
-                    "available since OpenSSH 6.5, Dropbear SSH 2020.79"
+                    "available since OpenSSH 6.5"
                ]
            }
        }
@@ -1,23 +1,23 @@
 [0;36m# general[0m
 [0;32m(gen) software: TinySSH noversion[0m
-[0;32m(gen) compatibility: OpenSSH 8.0-8.4, Dropbear SSH 2020.79+[0m
+[0;32m(gen) compatibility: OpenSSH 8.0-8.4, Dropbear SSH 2018.76+[0m
 [0;32m(gen) compression: disabled[0m

 [0;36m# key exchange algorithms[0m
 [0;32m(kex) curve25519-sha256                       -- [info] available since OpenSSH 7.4, Dropbear SSH 2018.76[0m
-[0;32m                                              `- [info] default key exchange from OpenSSH 7.4 to 8.9[0m
+[0;32m                                              `- [info] default key exchange from OpenSSH 6.4 to 8.9[0m
 [0;32m(kex) curve25519-sha256@libssh.org            -- [info] available since OpenSSH 6.4, Dropbear SSH 2013.62[0m
-[0;32m                                              `- [info] default key exchange from OpenSSH 6.5 to 7.3[0m
+[0;32m                                              `- [info] default key exchange from OpenSSH 6.4 to 8.9[0m
 [0;33m(kex) sntrup4591761x25519-sha512@tinyssh.org  -- [warn] using experimental algorithm[0m
                                              `- [info] available since OpenSSH 8.0
                                              `- [info] the sntrup4591761 algorithm was withdrawn, as it may not provide strong post-quantum security

 [0;36m# host-key algorithms[0m
-[0;32m(key) ssh-ed25519                             -- [info] available since OpenSSH 6.5, Dropbear SSH 2020.79[0m
+[0;32m(key) ssh-ed25519                             -- [info] available since OpenSSH 6.5[0m

 [0;36m# encryption algorithms (ciphers)[0m
 [0;33m(enc) chacha20-poly1305@openssh.com           -- [warn] vulnerable to the Terrapin attack (CVE-2023-48795), allowing message prefix truncation[0m
-                                              `- [info] available since OpenSSH 6.5, Dropbear SSH 2020.79
+                                              `- [info] available since OpenSSH 6.5
                                              `- [info] default cipher since OpenSSH 6.9

 [0;36m# message authentication code algorithms[0m
@@ -1,13 +0,0 @@
-#
-# Docker policy: test15
-#
-
-name = "Docker policy: test15"
-version = 1
-allow_algorithm_subset_and_reordering = true
-banner = "SSH-2.0-OpenSSH_8.0"
-compressions = none, zlib@openssh.com
-host keys = rsa-sha2-512, rsa-sha2-256, ssh-rsa, ecdsa-sha2-nistp256, ssh-ed25519, extra_hostkey_alg
-key exchanges = curve25519-sha256, curve25519-sha256@libssh.org, ecdh-sha2-nistp256, ecdh-sha2-nistp384, ecdh-sha2-nistp521, diffie-hellman-group-exchange-sha256, diffie-hellman-group16-sha512, diffie-hellman-group18-sha512, diffie-hellman-group14-sha256, diffie-hellman-group14-sha1, extra_kex_alg
-ciphers = chacha20-poly1305@openssh.com, aes128-ctr, aes192-ctr, aes256-ctr, aes128-gcm@openssh.com, aes256-gcm@openssh.com, extra_cipher_alg
-macs = umac-64-etm@openssh.com, umac-128-etm@openssh.com, hmac-sha2-256-etm@openssh.com, hmac-sha2-512-etm@openssh.com, hmac-sha1-etm@openssh.com, umac-64@openssh.com, umac-128@openssh.com, hmac-sha2-256, hmac-sha2-512, hmac-sha1, extra_mac_alg
@@ -1,13 +0,0 @@
-#
-# Docker policy: test16
-#
-
-name = "Docker policy: test16"
-version = 1
-allow_algorithm_subset_and_reordering = true
-banner = "SSH-2.0-OpenSSH_8.0"
-compressions = none, zlib@openssh.com
-host keys = rsa-sha2-512, extra_hostkey_alg
-key exchanges = curve25519-sha256, extra_kex_alg
-ciphers = chacha20-poly1305@openssh.com, extra_cipher_alg
-macs = umac-64-etm@openssh.com, extra_mac_alg
@@ -1,15 +0,0 @@
-#
-# Docker policy: test17
-#
-
-name = "Docker policy: test17"
-version = 1
-allow_larger_keys = true
-banner = "SSH-2.0-OpenSSH_8.0"
-compressions = none, zlib@openssh.com
-host keys = rsa-sha2-512, rsa-sha2-256, ssh-rsa, ecdsa-sha2-nistp256, ssh-ed25519
-key exchanges = curve25519-sha256, curve25519-sha256@libssh.org, ecdh-sha2-nistp256, ecdh-sha2-nistp384, ecdh-sha2-nistp521, diffie-hellman-group-exchange-sha256, diffie-hellman-group16-sha512, diffie-hellman-group18-sha512, diffie-hellman-group14-sha256, diffie-hellman-group14-sha1
-ciphers = chacha20-poly1305@openssh.com, aes128-ctr, aes192-ctr, aes256-ctr, aes128-gcm@openssh.com, aes256-gcm@openssh.com
-macs = umac-64-etm@openssh.com, umac-128-etm@openssh.com, hmac-sha2-256-etm@openssh.com, hmac-sha2-512-etm@openssh.com, hmac-sha1-etm@openssh.com, umac-64@openssh.com, umac-128@openssh.com, hmac-sha2-256, hmac-sha2-512, hmac-sha1
-host_key_sizes = {"ssh-rsa": {"hostkey_size": 2048}, "rsa-sha2-256": {"hostkey_size": 2048}, "rsa-sha2-512": {"hostkey_size": 2048}, "ssh-ed25519": {"hostkey_size": 256}}
-dh_modulus_sizes = {"diffie-hellman-group-exchange-sha256": 2048}
@@ -1,29 +0,0 @@
-import pytest
-
-from ssh_audit.ssh2_kexdb import SSH2_KexDB
-from ssh_audit.dheat import DHEat
-
-
-class TestDHEat:
-
-    @pytest.fixture(autouse=True)
-    def init(self):
-        self.SSH2_KexDB = SSH2_KexDB
-        self.DHEat = DHEat
-
-    def test_kex_definition_completeness(self):
-        alg_db = self.SSH2_KexDB.get_db()
-        kex_db = alg_db['kex']
-
-        # Get all Diffie-Hellman algorithms defined in our database.
-        dh_algs = []
-        for kex in kex_db:
-            if kex.startswith('diffie-hellman-'):
-                dh_algs.append(kex)
-
-        # Ensure that each DH algorithm in our database is in either DHEat's alg_priority or gex_algs list.  Also ensure that all non-group exchange algorithms are accounted for in the alg_modulus_sizes dictionary.
-        for dh_alg in dh_algs:
-            assert (dh_alg in self.DHEat.alg_priority) or (dh_alg in self.DHEat.gex_algs)
-
-            if dh_alg.find("group-exchange") == -1:
-                assert dh_alg in self.DHEat.alg_modulus_sizes
@@ -17,7 +17,6 @@ class TestErrors:
        conf = self.AuditConf('localhost', 22)
        conf.colors = False
        conf.batch = True
-        conf.skip_rate_test = True
        return conf

    def _audit(self, spy, conf=None, exit_expected=False):
@@ -150,7 +150,7 @@ ciphers = cipher_alg1, cipher_alg2, cipher_alg3
 macs = mac_alg1, mac_alg2, mac_alg3'''

        policy = self.Policy(policy_data=policy_data)
-        assert str(policy) == "Name: [Test Policy]\nVersion: [1]\nAllow Algorithm Subset and/or Reordering: False\nBanner: {undefined}\nCompressions: comp_alg1\nHost Keys: key_alg1\nOptional Host Keys: {undefined}\nKey Exchanges: kex_alg1, kex_alg2\nCiphers: cipher_alg1, cipher_alg2, cipher_alg3\nMACs: mac_alg1, mac_alg2, mac_alg3\nHost Key Sizes: {undefined}\nDH Modulus Sizes: {undefined}\nServer Policy: True"
+        assert str(policy) == "Name: [Test Policy]\nVersion: [1]\nBanner: {undefined}\nCompressions: comp_alg1\nHost Keys: key_alg1\nOptional Host Keys: {undefined}\nKey Exchanges: kex_alg1, kex_alg2\nCiphers: cipher_alg1, cipher_alg2, cipher_alg3\nMACs: mac_alg1, mac_alg2, mac_alg3\nHost Key Sizes: {undefined}\nDH Modulus Sizes: {undefined}\nServer Policy: True"


    def test_policy_invalid_1(self):
@@ -297,7 +297,7 @@ macs = mac_alg1, mac_alg2, mac_alg3'''
        pol_data = pol_data.replace(date.today().strftime('%Y/%m/%d'), '[todays date]')

        # Instead of writing out the entire expected policy--line by line--just check that it has the expected hash.
-        assert hashlib.sha256(pol_data.encode('ascii')).hexdigest() == 'fb84bce442cff2bce9bf653d6373a8a938e3bfcfbd1e876f51a08c1842df3cff'
+        assert hashlib.sha256(pol_data.encode('ascii')).hexdigest() == '4af7777fb57a1dad0cf438c899a11d4f625fd9276ea3bb5ef5c9fe8806cb47dc'


    def test_policy_evaluate_passing_1(self):
@@ -440,96 +440,3 @@ macs = mac_alg1, mac_alg2, XXXmismatchedXXX, mac_alg3'''
        assert len(errors) == 2
        assert error_str.find('Host keys did not match.') != -1
        assert error_str.find('MACs did not match.') != -1
-
-
-    def test_policy_evaluate_subset_passing_1(self):
-        '''Ensure that exact algorithm matches work even when subset parsing is enabled.'''
-
-        policy_data = '''name = "Test Policy"
-version = 1
-allow_algorithm_subset_and_reordering = true
-compressions = comp_alg1, comp_alg2
-host keys = key_alg1, key_alg2
-key exchanges = kex_alg1, kex_alg2
-ciphers = cipher_alg1, cipher_alg2, cipher_alg3
-macs = mac_alg1, mac_alg2, mac_alg3'''
-        policy = self.Policy(policy_data=policy_data)
-        ret, errors, error_str = policy.evaluate('SSH Server 1.0', self._get_kex())
-        assert ret is True
-        assert len(errors) == 0
-        assert error_str == ""
-
-
-    def test_policy_evaluate_subset_passing_2(self):
-        '''Ensure that subset parsing works.'''
-
-        policy_data = '''name = "Test Policy"
-version = 1
-allow_algorithm_subset_and_reordering = true
-compressions = comp_alg1, comp_alg2
-host keys = key_alg2, key_alg1, key_alg0
-key exchanges = kex_alg3, kex_alg1, kex_alg2
-ciphers = cipher_alg0, cipher_alg3, cipher_alg2, cipher_alg1
-macs = mac_alg2, mac_alg1, mac_alg3, mac_alg0'''
-        policy = self.Policy(policy_data=policy_data)
-        ret, errors, error_str = policy.evaluate('SSH Server 1.0', self._get_kex())
-        assert ret is True
-        assert len(errors) == 0
-        assert error_str == ""
-
-
-    def test_policy_evaluate_subset_failing_1(self):
-        '''Ensure that subset parsing returns a failure.'''
-
-        policy_data = '''name = "Test Policy"
-version = 1
-allow_algorithm_subset_and_reordering = true
-compressions = comp_alg1, comp_alg2
-host keys = key_alg7, key_alg8, key_alg9
-key exchanges = kex_alg7, kex_alg8, kex_alg9
-ciphers = cipher_alg7, cipher_alg8, cipher_alg9, cipher_alg10
-macs = mac_alg7, mac_alg8, mac_alg9, mac_alg10'''
-        policy = self.Policy(policy_data=policy_data)
-        ret, errors, error_str = policy.evaluate('SSH Server 1.0', self._get_kex())
-        assert ret is False
-        assert len(errors) == 4
-        assert error_str.find("Ciphers did not match.") != -1
-        assert error_str.find("Host keys did not match.") != -1
-        assert error_str.find("MACs did not match") != -1
-        assert error_str.find("Key exchanges did not match.") != -1
-
-
-    def test_policy_evaluate_subset_failing_2(self):
-        '''Ensure that subset parsing returns a failure when policy includes kex-strict-s-v00@openssh.com, but target does not.'''
-
-        policy_data = '''name = "Test Policy"
-version = 1
-allow_algorithm_subset_and_reordering = true
-compressions = comp_alg1, comp_alg2
-host keys = key_alg2, key_alg1, key_alg0
-key exchanges = kex_alg3, kex_alg1, kex_alg2, kex-strict-s-v00@openssh.com
-ciphers = cipher_alg0, cipher_alg3, cipher_alg2, cipher_alg1
-macs = mac_alg2, mac_alg1, mac_alg3, mac_alg0'''
-        policy = self.Policy(policy_data=policy_data)
-        ret, errors, error_str = policy.evaluate('SSH Server 1.0', self._get_kex())
-        assert ret is False
-        assert len(errors) == 1
-        assert error_str.find("Key exchanges did not match.") != -1
-
-
-    def test_policy_evaluate_subset_failing_3(self):
-        '''Ensure that subset parsing returns a failure when policy includes kex-strict-c-v00@openssh.com, but target does not.'''
-
-        policy_data = '''name = "Test Policy"
-version = 1
-allow_algorithm_subset_and_reordering = true
-compressions = comp_alg1, comp_alg2
-host keys = key_alg2, key_alg1, key_alg0
-key exchanges = kex_alg3, kex_alg1, kex_alg2, kex-strict-c-v00@openssh.com
-ciphers = cipher_alg0, cipher_alg3, cipher_alg2, cipher_alg1
-macs = mac_alg2, mac_alg1, mac_alg3, mac_alg0'''
-        policy = self.Policy(policy_data=policy_data)
-        ret, errors, error_str = policy.evaluate('SSH Server 1.0', self._get_kex())
-        assert ret is False
-        assert len(errors) == 1
-        assert error_str.find("Key exchanges did not match.") != -1
@@ -33,7 +33,6 @@ class TestSSH1:
        conf.verbose = True
        conf.ssh1 = True
        conf.ssh2 = False
-        conf.skip_rate_test = True
        return conf

    def _create_ssh1_packet(self, payload, valid_crc=True):
@@ -32,7 +32,6 @@ class TestSSH2:
        conf.verbose = True
        conf.ssh1 = False
        conf.ssh2 = True
-        conf.skip_rate_test = True
        return conf

    @classmethod
@@ -1,7 +1,7 @@
 [tox]
 envlist =
-	py{py3}-{test,pylint,flake8}
-	py{38,39,310,311,312}-{test,mypy,pylint,flake8}
+	py{py3}-{test,pylint,flake8,vulture}
+	py{38,39,310,311,312}-{test,mypy,pylint,flake8,vulture}
 	cov
 skip_missing_interpreters = true

@@ -13,6 +13,7 @@ deps =
 	py{38,39,310,311,312}-{type,mypy}: {[testenv:mypy]deps}
 	py{py3,38,39,310,311,312}-{lint,pylint},lint: {[testenv:pylint]deps}
 	py{py3,38,39,310,311,312}-{lint,flake8},lint: {[testenv:flake8]deps}
+	py{py3,38,39,310,311,312}-{lint,vulture},lint: {[testenv:vulture]deps}
 setenv =
 	SSHAUDIT = {toxinidir}/src
 	test: COVERAGE_FILE = {toxinidir}/.coverage.{envname}
@@ -27,7 +28,7 @@ commands =
 	py{38,39,310,311,312}-{type,mypy}: {[testenv:mypy]commands}
 	py{py3,38,39,310,311,312}-{lint,pylint},lint: {[testenv:pylint]commands}
 	py{py3,38,39,310,311,312}-{lint,flake8},lint: {[testenv:flake8]commands}
-
+	py{py3,38,39,310,311,312}-{lint,vulture},lint: {[testenv:vulture]commands}
 #ignore_outcome =
 #	type: true
 #	lint: true
@@ -74,6 +75,17 @@ deps =
 commands =
 	flake8 {posargs:{env:SSHAUDIT} {toxinidir}/setup.py {toxinidir}/test {toxinidir}/ssh-audit.py}  --statistics

+[testenv:vulture]
+deps =
+	vulture
+commands =
+	python -c "import sys; from subprocess import Popen, PIPE; \
+		a = ['vulture', '--min-confidence', '100'] + r'{posargs:{env:SSHAUDIT}}'.split(' '); \
+		o = Popen(a, shell=False, stdout=PIPE).communicate()[0]; \
+		l = [x for x in o.split(b'\n') if x and b'Unused import' not in x]; \
+		print(b'\n'.join(l).decode('utf-8')); \
+		sys.exit(1 if len(l) > 0 else 0)"
+
 [pylint]
 reports = no
 #output-format = colorized
@@ -89,14 +101,11 @@ disable =
        no-else-return,
        super-with-arguments,   # Can be re-factored, at some point.
        too-complex,
-        too-many-arguments,
        too-many-boolean-expressions,
        too-many-branches,
        too-many-instance-attributes,
        too-many-lines,
        too-many-locals,
-        too-many-nested-blocks,
-        too-many-return-statements,
        too-many-statements,
        consider-using-f-string
 max-complexity = 15
Author	SHA1	Message	Date
yannik1015	b3a86e64fa	Merge `31df27ec3e` into `7b3402b207`	2024-03-15 18:36:01 -04:00
yannik1015	31df27ec3e	Adapted policy.py to newest dev version	2024-03-15 15:57:05 +01:00
yannik1015	332a1a9c1d	Added allowed policy fields Added allowed fields for host keys kex ciphers and macs	2024-03-15 15:41:56 +01:00