asyncssh 2.18.0__tar.gz → 2.20.0__tar.gz

{asyncssh-2.18.0 → asyncssh-2.20.0}/.github/workflows/run_tests.yml

@@ -8,7 +8,7 @@ jobs:
       fail-fast: false
       matrix:
         os: [ubuntu-latest, macos-latest, windows-latest]
-        python-version: ["3.7", "3.8", "3.9", "3.10", "3.11", "3.12"]
+        python-version: ["3.8", "3.9", "3.10", "3.11", "3.12", "3.13"]
         include:
           - os: macos-latest
             python-version: "3.10"
@@ -19,22 +19,9 @@ jobs:
           - os: macos-latest
             python-version: "3.12"
             openssl-version: "3"
-        exclude:
-          # having trouble with arch arm64 on macos-ltest on Python 3.7
           - os: macos-latest
-            python-version: "3.7"
-
-          # test hangs on these combination
-          - os: windows-latest
-            python-version: "3.8"
-          - os: windows-latest
-            python-version: "3.9"
-          - os: windows-latest
-            python-version: "3.10"
-          - os: windows-latest
-            python-version: "3.11"
-          - os: windows-latest
-            python-version: "3.12"
+            python-version: "3.13"
+            openssl-version: "3"
 
     runs-on: ${{ matrix.os }}
     env:
@@ -153,8 +140,6 @@ jobs:
     steps:
       - uses: actions/checkout@v4
       - uses: actions/setup-python@v5
-        with:
-          python-version: "3.7"
       - uses: actions/download-artifact@v4
         with:
           name: coverage

{asyncssh-2.18.0/asyncssh.egg-info → asyncssh-2.20.0}/PKG-INFO

@@ -1,32 +1,31 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: asyncssh
-Version: 2.18.0
+Version: 2.20.0
 Summary: AsyncSSH: Asynchronous SSHv2 client and server library
-Home-page: http://asyncssh.timeheart.net
-Author: Ron Frederick
-Author-email: ronf@timeheart.net
-License: Eclipse Public License v2.0
+Author-email: Ron Frederick <ronf@timeheart.net>
+License: EPL-2.0 OR GPL-2.0-or-later
+Project-URL: Homepage, http://asyncssh.timeheart.net
 Project-URL: Documentation, https://asyncssh.readthedocs.io
 Project-URL: Source, https://github.com/ronf/asyncssh
 Project-URL: Tracker, https://github.com/ronf/asyncssh/issues
-Platform: Any
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved
 Classifier: Operating System :: MacOS :: MacOS X
 Classifier: Operating System :: POSIX
-Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Internet
 Classifier: Topic :: Security :: Cryptography
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: System :: Networking
-Requires-Python: >= 3.6
+Requires-Python: >=3.6
+Description-Content-Type: text/x-rst
 License-File: LICENSE
 Requires-Dist: cryptography>=39.0
 Requires-Dist: typing_extensions>=4.0.0

{asyncssh-2.18.0 → asyncssh-2.20.0}/asyncssh/client.py

@@ -220,6 +220,15 @@ class SSHClient:
 
         """
 
+    def begin_auth(self, username: str) -> None:
+        """Begin client authentication
+
+           This method is called when client authentication is about to
+           begin, Applications may store the username passed here to
+           be used in future authentication callbacks.
+
+        """
+
     def auth_completed(self) -> None:
         """Authentication was completed successfully
 

{asyncssh-2.18.0 → asyncssh-2.20.0}/asyncssh/config.py

@@ -41,6 +41,10 @@ from .pattern import HostPatternList, WildcardPatternList
 ConfigPaths = Union[None, FilePath, Sequence[FilePath]]
 
 
+_token_pattern = re.compile(r'%(.)')
+_env_pattern = re.compile(r'\${(.*)}')
+
+
 def _exec(cmd: str) -> bool:
     """Execute a command and return if exit status is 0"""
 
@@ -60,12 +64,15 @@ class SSHConfig:
     _percent_expand = {'AuthorizedKeysFile'}
     _handlers: Dict[str, Tuple[str, Callable]] = {}
 
-    def __init__(self, last_config: Optional['SSHConfig'], reload: bool):
+    def __init__(self, last_config: Optional['SSHConfig'], reload: bool,
+                 canonical: bool, final: bool):
         if last_config:
             self._last_options = last_config.get_options(reload)
         else:
             self._last_options = {}
 
+        self._canonical = canonical
+        self._final = True if final else None
         self._default_path = Path('~', '.ssh').expanduser()
         self._path = Path()
         self._line_no = 0
@@ -90,36 +97,38 @@ class SSHConfig:
 
         raise NotImplementedError
 
-    def _expand_val(self, value: str) -> str:
-        """Perform percent token expansion on a string"""
+    def _expand_token(self, match):
+        """Expand a percent token reference"""
 
-        last_idx = 0
-        result: List[str] = []
+        try:
+            token = match.group(1)
+            return self._tokens[token]
+        except KeyError:
+            if token == 'd':
+                raise ConfigParseError('Home directory is '
+                                       'not available') from None
+            elif token == 'i':
+                raise ConfigParseError('User id not available') from None
+            else:
+                raise ConfigParseError('Invalid token expansion: ' +
+                                       token) from None
 
-        for match in re.finditer(r'%', value):
-            idx = match.start()
+    @staticmethod
+    def _expand_env(match):
+        """Expand an environment variable reference"""
 
-            if idx < last_idx:
-                continue
+        try:
+            var = match.group(1)
+            return os.environ[var]
+        except KeyError:
+            raise ConfigParseError('Invalid environment expansion: ' +
+                                   var) from None
 
-            try:
-                token = value[idx+1]
-                result.extend([value[last_idx:idx], self._tokens[token]])
-                last_idx = idx + 2
-            except IndexError:
-                raise ConfigParseError('Invalid token substitution') from None
-            except KeyError:
-                if token == 'd':
-                    raise ConfigParseError('Home directory is '
-                                           'not available') from None
-                elif token == 'i':
-                    raise ConfigParseError('User id not available') from None
-                else:
-                    raise ConfigParseError('Invalid token substitution: ' +
-                                           value[idx+1]) from None
-
-        result.append(value[last_idx:])
-        return ''.join(result)
+    def _expand_val(self, value: str) -> str:
+        """Perform percent token and environment expansion on a string"""
+
+        return _env_pattern.sub(self._expand_env,
+                                _token_pattern.sub(self._expand_token, value))
 
     def _include(self, option: str, args: List[str]) -> None:
         """Read config from a list of other config files"""
@@ -153,35 +162,53 @@ class SSHConfig:
 
         # pylint: disable=unused-argument
 
+        matching = True
+
         while args:
             match = args.pop(0).lower()
 
+            if match[0] == '!':
+                match = match[1:]
+                negated = True
+            else:
+                negated = False
+
+            if match == 'final' and self._final is None:
+                self._final = False
+
             if match == 'all':
-                self._matching = True
-                continue
+                result = True
+            elif match == 'canonical':
+                result = self._canonical
+            elif match == 'final':
+                result = cast(bool, self._final)
+            else:
+                match_val = self._match_val(match)
+
+                if match != 'exec' and match_val is None:
+                    self._error(f'Invalid match condition {match}')
 
-            match_val = self._match_val(match)
+                try:
+                    arg = args.pop(0)
+                except IndexError:
+                    self._error(f'Missing {match} match pattern')
+
+                if matching:
+                    if match == 'exec':
+                        result = _exec(arg)
+                    elif match in ('address', 'localaddress'):
+                        host_pat = HostPatternList(arg)
+                        ip = ip_address(cast(str, match_val)) \
+                            if match_val else None
+                        result = host_pat.matches(None, match_val, ip)
+                    else:
+                        wild_pat = WildcardPatternList(arg)
+                        result = wild_pat.matches(match_val)
 
-            if match != 'exec' and match_val is None:
-                self._error('Invalid match condition')
+            if matching and result == negated:
+                matching = False
 
-            try:
-                if match == 'exec':
-                    self._matching = _exec(args.pop(0))
-                elif match in ('address', 'localaddress'):
-                    host_pat = HostPatternList(args.pop(0))
-                    ip = ip_address(cast(str, match_val)) \
-                        if match_val else None
-                    self._matching = host_pat.matches(None, match_val, ip)
-                else:
-                    wild_pat = WildcardPatternList(args.pop(0))
-                    self._matching = wild_pat.matches(match_val)
-            except IndexError:
-                self._error(f'Missing {match} match pattern')
-
-            if not self._matching:
-                args.clear()
-                break
+        self._matching = matching
 
     def _set_bool(self, option: str, args: List[str]) -> None:
         """Set a boolean config option"""
@@ -198,6 +225,22 @@ class SSHConfig:
         if option not in self._options:
             self._options[option] = value
 
+    def _set_bool_or_str(self, option: str, args: List[str]) -> None:
+        """Set a boolean or string config option"""
+
+        value_str = args.pop(0)
+        value_lower = value_str.lower()
+
+        if value_lower in ('yes', 'true'):
+            value: Union[bool, str] = True
+        elif value_lower in ('no', 'false'):
+            value = False
+        else:
+            value = value_str
+
+        if option not in self._options:
+            self._options[option] = value
+
     def _set_int(self, option: str, args: List[str]) -> None:
         """Set an integer config option"""
 
@@ -276,6 +319,23 @@ class SSHConfig:
         if option not in self._options:
             self._options[option] = value
 
+    def _set_canonicalize_host(self, option: str, args: List[str]) -> None:
+        """Set a canonicalize host config option"""
+
+        value_str = args.pop(0).lower()
+
+        if value_str in ('yes', 'true'):
+            value: Union[bool, str] = True
+        elif value_str in ('no', 'false'):
+            value = False
+        elif value_str == 'always':
+            value = value_str
+        else:
+            self._error(f'Invalid {option} value: {value_str}')
+
+        if option not in self._options:
+            self._options[option] = value
+
     def _set_rekey_limits(self, option: str, args: List[str]) -> None:
         """Set rekey limits config option"""
 
@@ -295,6 +355,11 @@ class SSHConfig:
         if option not in self._options:
             self._options[option] = byte_limit, time_limit
 
+    def has_match_final(self) -> bool:
+        """Return whether this config includes a 'Match final' block"""
+
+        return self._final is not None
+
     def parse(self, path: Path) -> None:
         """Parse an OpenSSH config file and return matching declarations"""
 
@@ -384,10 +449,10 @@ class SSHConfig:
     @classmethod
     def load(cls, last_config: Optional['SSHConfig'],
              config_paths: ConfigPaths, reload: bool,
-             *args: object) -> 'SSHConfig':
+             canonical: bool, final: bool, *args: object) -> 'SSHConfig':
         """Load a list of OpenSSH config files into a config object"""
 
-        config = cls(last_config, reload, *args)
+        config = cls(last_config, reload, canonical, final, *args)
 
         if config_paths:
             if isinstance(config_paths, (str, PurePath)):
@@ -425,12 +490,13 @@ class SSHClientConfig(SSHConfig):
 
     _conditionals = {'host', 'match'}
     _no_split = {'proxycommand', 'remotecommand'}
-    _percent_expand = {'CertificateFile', 'IdentityAgent',
+    _percent_expand = {'CertificateFile', 'ForwardAgent', 'IdentityAgent',
                        'IdentityFile', 'ProxyCommand', 'RemoteCommand'}
 
     def __init__(self, last_config: 'SSHConfig', reload: bool,
-                 local_user: str, user: str, host: str, port: int) -> None:
-        super().__init__(last_config, reload)
+                 canonical: bool, final: bool, local_user: str,
+                 user: str, host: str, port: int) -> None:
+        super().__init__(last_config, reload, canonical, final)
 
         self._local_user = local_user
         self._orig_host = host
@@ -485,10 +551,10 @@ class SSHClientConfig(SSHConfig):
             value: Union[bool, str] = True
         elif value_str in ('no', 'false'):
             value = False
-        elif value_str not in ('force', 'auto'):
-            self._error(f'Invalid {option} value: {value_str}')
-        else:
+        elif value_str in ('force', 'auto'):
             value = value_str
+        else:
+            self._error(f'Invalid {option} value: {value_str}')
 
         if option not in self._options:
             self._options[option] = value
@@ -531,6 +597,11 @@ class SSHClientConfig(SSHConfig):
 
         ('AddressFamily',                   SSHConfig._set_address_family),
         ('BindAddress',                     SSHConfig._set_string),
+        ('CanonicalDomains',                SSHConfig._set_string_list),
+        ('CanonicalizeFallbackLocal',       SSHConfig._set_bool),
+        ('CanonicalizeHostname',            SSHConfig._set_canonicalize_host),
+        ('CanonicalizeMaxDots',             SSHConfig._set_int),
+        ('CanonicalizePermittedCNAMEs',     SSHConfig._set_string_list),
         ('CASignatureAlgorithms',           SSHConfig._set_string),
         ('CertificateFile',                 SSHConfig._append_string),
         ('ChallengeResponseAuthentication', SSHConfig._set_bool),
@@ -538,7 +609,7 @@ class SSHClientConfig(SSHConfig):
         ('Compression',                     SSHConfig._set_bool),
         ('ConnectTimeout',                  SSHConfig._set_int),
         ('EnableSSHKeySign',                SSHConfig._set_bool),
-        ('ForwardAgent',                    SSHConfig._set_bool),
+        ('ForwardAgent',                    SSHConfig._set_bool_or_str),
         ('ForwardX11Trusted',               SSHConfig._set_bool),
         ('GlobalKnownHostsFile',            SSHConfig._set_string_list),
         ('GSSAPIAuthentication',            SSHConfig._set_bool),
@@ -579,9 +650,9 @@ class SSHServerConfig(SSHConfig):
     """Settings from an OpenSSH server config file"""
 
     def __init__(self, last_config: 'SSHConfig', reload: bool,
-                 local_addr: str, local_port: int, user: str,
-                 host: str, addr: str) -> None:
-        super().__init__(last_config, reload)
+                 canonical: bool, final: bool, local_addr: str,
+                 local_port: int, user: str, host: str, addr: str) -> None:
+        super().__init__(last_config, reload, canonical, final)
 
         self._local_addr = local_addr
         self._local_port = local_port
@@ -618,6 +689,11 @@ class SSHServerConfig(SSHConfig):
         ('AuthorizedKeysFile',              SSHConfig._set_string_list),
         ('AllowAgentForwarding',            SSHConfig._set_bool),
         ('BindAddress',                     SSHConfig._set_string),
+        ('CanonicalDomains',                SSHConfig._set_string_list),
+        ('CanonicalizeFallbackLocal',       SSHConfig._set_bool),
+        ('CanonicalizeHostname',            SSHConfig._set_canonicalize_host),
+        ('CanonicalizeMaxDots',             SSHConfig._set_int),
+        ('CanonicalizePermittedCNAMEs',     SSHConfig._set_string_list),
         ('CASignatureAlgorithms',           SSHConfig._set_string),
         ('ChallengeResponseAuthentication', SSHConfig._set_bool),
         ('Ciphers',                         SSHConfig._set_string),