asyncssh の API リファレンス

asyncssh (ronf/asyncssh) の公開 API 400 件 —— クラス 97、関数 68、メソッド 235。実際のソースを静的解析して抽出した正確なシグネチャを掲載しています。

種別	件数
クラス	97
関数	68
メソッド	235

API 一覧

classasyncssh.agent.AgentReader

Protocol for reading from an SSH agent

methodasyncssh.agent.AgentReader.readexactly(n:int) -> bytes

Read exactly n bytes from the SSH agent

classasyncssh.agent.AgentWriter

Protocol for writing to an SSH agent

methodasyncssh.agent.AgentWriter.close() -> None

Close connection to the SSH agent

methodasyncssh.agent.AgentWriter.wait_closed() -> None

Wait for the connection to the SSH agent to close

methodasyncssh.agent.AgentWriter.write(data:bytes) -> None

Write bytes to the SSH agent

classasyncssh.agent.SSHAgentClient

SSH agent client

methodasyncssh.agent.SSHAgentClient.connect() -> None

Connect to the SSH agent

methodasyncssh.agent.SSHAgentClient.encode_constraints(lifetime:Optional[int], confirm:bool) -> bytes

Encode key constraints

methodasyncssh.agent.SSHAgentClient.lock(passphrase:str) -> None

Lock the agent using the specified passphrase ..

methodasyncssh.agent.SSHAgentClient.sign(key_blob:bytes, data:bytes, flags:int=0) -> bytes

Sign a block of data with the requested key

methodasyncssh.agent.SSHAgentClient.unlock(passphrase:str) -> None

Unlock the agent using the specified passphrase ..

classasyncssh.agent.SSHAgentKeyPair

Surrogate for a key managed by the SSH agent

methodasyncssh.agent.SSHAgentKeyPair.has_cert() -> bool

Return if this key pair has an associated cert

methodasyncssh.agent.SSHAgentKeyPair.remove() -> None

Remove this key pair from the agent

methodasyncssh.agent.SSHAgentKeyPair.set_certificate(cert:SSHCertificate) -> None

Set certificate to use with this key

methodasyncssh.agent.SSHAgentKeyPair.set_sig_algorithm(sig_algorithm:bytes) -> None

Set the signature algorithm to use when signing data

methodasyncssh.agent.SSHAgentKeyPair.sign_async(data:bytes) -> bytes

Asynchronously sign a block of data with this private key

classasyncssh.agent.SSHAgentListener

Listener used to forward agent connections

methodasyncssh.agent.SSHAgentListener.close() -> None

Close the agent listener

methodasyncssh.agent.SSHAgentListener.get_path() -> str

Return the path being listened on

funcasyncssh.agent_unix.open_agent(agent_path:str) -> Tuple['AgentReader', 'AgentWriter']

Open a connection to ssh-agent

funcasyncssh.agent_win32.open_agent(agent_path:str) -> Tuple['AgentReader', 'AgentWriter']

Open a connection to the Pageant or Windows 10 OpenSSH agent

classasyncssh.asn1.ASN1DecodeError

ASN.1 DER decoding error

classasyncssh.asn1.ASN1EncodeError

ASN.1 DER encoding error

classasyncssh.asn1.ASN1Error

ASN.1 coding error

methodasyncssh.asn1.BitString.decode(constructed:bool, content:bytes) -> 'BitString'

Decode a DER bit string

methodasyncssh.asn1.BitString.encode(value:object) -> bytes

Encode a DER bit string

classasyncssh.asn1.DERType

Parent class for classes which use DERTag decorator

methodasyncssh.asn1.DERType.decode(constructed:bool, content:bytes) -> object

Decode a DER byte string into an object

methodasyncssh.asn1.DERType.encode(value:object) -> bytes

Encode value as a DER byte string

classasyncssh.asn1.IA5String

An ASCII string value

methodasyncssh.asn1.IA5String.decode(constructed:bool, content:bytes) -> 'IA5String'

Decode a DER IA5 string

methodasyncssh.asn1.IA5String.encode(value:object) -> bytes

Encode a DER IA5 string

methodasyncssh.asn1.ObjectIdentifier.decode(constructed:bool, content:bytes) -> 'ObjectIdentifier'

Decode a DER object identifier

methodasyncssh.asn1.ObjectIdentifier.encode(value:object) -> bytes

Encode a DER object identifier

funcasyncssh.asn1.der_decode_partial(data:bytes) -> Tuple[object, int]

Decode a value in DER format and return the number of bytes consumed

classasyncssh.auth.Auth

Parent class for authentication

methodasyncssh.auth.Auth.cancel() -> None

Cancel any authentication in progress

methodasyncssh.auth.Auth.create_task(coro:Awaitable[None]) -> None

Create an asynchronous auth task

methodasyncssh.auth.Auth.logger() -> SSHLogger

A logger associated with this authentication handler

methodasyncssh.auth.Auth.send_packet(pkttype:int, *trivial:bool=True, *args:bytes) -> None

Send an auth packet

classasyncssh.auth.ClientAuth

Parent class for client authentication

methodasyncssh.auth.ClientAuth.auth_failed() -> None

Callback when auth fails

methodasyncssh.auth.ClientAuth.auth_succeeded() -> None

Callback when auth succeeds

methodasyncssh.auth.ClientAuth.send_request(*key:Optional[SigningKey]=None, *trivial:bool=True, *args:bytes) -> None

Send a user authentication request

classasyncssh.auth.ServerAuth

Parent class for server authentication

methodasyncssh.auth.ServerAuth.send_failure(partial_success:bool=False) -> None

Send a user authentication failure response

methodasyncssh.auth.ServerAuth.send_success() -> None

Send a user authentication success response

methodasyncssh.auth.ServerAuth.supported(conn:'SSHServerConnection') -> bool

Return whether this authentication method is supported

funcasyncssh.auth.get_supported_client_auth_methods() -> Sequence[bytes]

Return a list of supported client auth methods

funcasyncssh.auth.get_supported_server_auth_methods(conn:'SSHServerConnection') -> Sequence[bytes]

Return a list of supported server auth methods

funcasyncssh.auth.lookup_client_auth(conn:'SSHClientConnection', method:bytes) -> Optional[ClientAuth]

Look up the client authentication method to use

func

asyncssh.auth.lookup_server_auth(conn:'SSHServerConnection', username:str, method:bytes, packet:SSHPacket) -> Optional[ServerAuth]

Look up the server authentication method to use

funcasyncssh.auth.register_auth_method(alg:bytes, client_handler:Type[ClientAuth], server_handler:Type[ServerAuth]) -> None

classasyncssh.auth_keys.SSHAuthorizedKeys

An SSH authorized keys list

methodasyncssh.auth_keys.SSHAuthorizedKeys.load(authorized_keys:str) -> None

Load authorized keys data into this object

classasyncssh.channel.SSHAgentChannel

SSH agent channel

methodasyncssh.channel.SSHAgentChannel.open(session_factory:SSHUNIXSessionFactory[bytes]) -> SSHUNIXSession[bytes]

Open an SSH agent channel

classasyncssh.channel.SSHChannel

Parent class for SSH channels

methodasyncssh.channel.SSHChannel.get_connection() -> 'SSHConnection'

Return the connection used by this channel

methodasyncssh.channel.SSHChannel.get_encoding() -> Tuple[Optional[str], str]

Return the encoding used by this channel

methodasyncssh.channel.SSHChannel.get_loop() -> asyncio.AbstractEventLoop

Return the event loop used by this channel

methodasyncssh.channel.SSHChannel.get_read_datatypes() -> Set[int]

Return the legal read data types for this channel

methodasyncssh.channel.SSHChannel.get_recv_window() -> int

Return the configured receive window for this channel

methodasyncssh.channel.SSHChannel.get_write_datatypes() -> Set[int]

Return the legal write data types for this channel

methodasyncssh.channel.SSHChannel.is_closing() -> bool

Return if the channel is closing or is closed

methodasyncssh.channel.SSHChannel.logger() -> SSHLogger

A logger associated with this channel

methodasyncssh.channel.SSHChannel.process_connection_close(exc:Optional[Exception]) -> None

Process the SSH connection closing

method

asyncssh.channel.SSHChannel.process_open(send_chan:int, send_window:int, send_pktsize:int, session:MaybeAwait[SSHSession[AnyStr]]) -> None

Process a channel open request

method

asyncssh.channel.SSHChannel.process_open_confirmation(send_chan:int, send_window:int, send_pktsize:int, packet:SSHPacket) -> None

Process a channel open confirmation

methodasyncssh.channel.SSHChannel.process_open_failure(code:int, reason:str, lang:str) -> None

Process a channel open failure

methodasyncssh.channel.SSHChannel.send_packet(pkttype:int, *args:bytes) -> None

Send a packet on the channel

methodasyncssh.channel.SSHChannel.set_encoding(encoding:Optional[str], errors:str='strict') -> None

Set the encoding on this channel

classasyncssh.channel.SSHClientChannel

SSH client channel

classasyncssh.channel.SSHForwardChannel

SSH channel for forwarding TCP and UNIX domain connections

classasyncssh.channel.SSHServerChannel

SSH server channel

classasyncssh.channel.SSHTCPChannel

SSH TCP channel

method

asyncssh.channel.SSHTCPChannel.accept(session_factory:SSHTCPSessionFactory[AnyStr], host:str, port:int, orig_host:str, orig_port:int) -> SSHTCPSession[AnyStr]

Create a new forwarded TCP session

method

asyncssh.channel.SSHTCPChannel.connect(session_factory:SSHTCPSessionFactory[AnyStr], host:str, port:int, orig_host:str, orig_port:int) -> SSHTCPSession[AnyStr]

Create a new outbound TCP session

method

asyncssh.channel.SSHTCPChannel.set_inbound_peer_names(dest_host:str, dest_port:int, orig_host:str, orig_port:int) -> None

Set local and remote peer names for inbound connections

classasyncssh.channel.SSHTunTapChannel

SSH TunTap channel

method

asyncssh.channel.SSHTunTapChannel.open(session_factory:SSHTunTapSessionFactory, mode:int, unit:Optional[int]) -> SSHTunTapSession

Open a TUN/TAP channel

methodasyncssh.channel.SSHTunTapChannel.set_mode(mode:int) -> None

Set mode for inbound connections

methodasyncssh.channel.SSHTunTapChannel.write(data:bytes, datatype:DataType=None) -> None

Add address family in outbound packets in TUN mode

classasyncssh.channel.SSHUNIXChannel

SSH UNIX channel

method

asyncssh.channel.SSHUNIXChannel.accept(session_factory:SSHUNIXSessionFactory[AnyStr], path:str) -> SSHUNIXSession[AnyStr]

Create a new forwarded UNIX session

method

asyncssh.channel.SSHUNIXChannel.connect(session_factory:SSHUNIXSessionFactory[AnyStr], path:str) -> SSHUNIXSession[AnyStr]

Create a new outbound UNIX session

methodasyncssh.channel.SSHUNIXChannel.set_inbound_peer_names(dest_path:str) -> None

Set local and remote peer names for inbound connections

classasyncssh.channel.SSHX11Channel

SSH X11 channel

method

asyncssh.channel.SSHX11Channel.open(session_factory:SSHTCPSessionFactory[bytes], orig_host:str, orig_port:int) -> SSHTCPSession[bytes]

Open an SSH X11 channel

methodasyncssh.channel.SSHX11Channel.set_inbound_peer_names(orig_host:str, orig_port:int) -> None

Set local and remote peer name for inbound connections

classasyncssh.compression.Compressor

Base class for data compressor

methodasyncssh.compression.Compressor.compress(data:bytes) -> Optional[bytes]

Compress data

classasyncssh.compression.Decompressor

Base class for data decompressor

methodasyncssh.compression.Decompressor.decompress(data:bytes) -> Optional[bytes]

Decompress data

funcasyncssh.compression.get_compression_algs() -> List[bytes]

Return supported compression algorithms

funcasyncssh.compression.get_default_compression_algs() -> List[bytes]

Return default compression algorithms

func

asyncssh.compression.register_compression_alg(alg:bytes, compressor:_CompressorType, decompressor:_DecompressorType, after_auth:bool, default:bool) -> None

classasyncssh.config.ConfigParseError

Configuration parsing exception

classasyncssh.config.SSHClientConfig

Settings from an OpenSSH client config file

classasyncssh.config.SSHConfig

Settings from an OpenSSH config file

methodasyncssh.config.SSHConfig.get(option:str, default:object=None) -> object

Get the value of a config option

methodasyncssh.config.SSHConfig.get_compression_algs() -> DefTuple[str]

Return the compression algorithms to use

methodasyncssh.config.SSHConfig.get_options(reload:bool) -> Dict[str, object]

Return options to base a new config object on

methodasyncssh.config.SSHConfig.has_match_final() -> bool

Return whether this config includes a 'Match final' block

methodasyncssh.config.SSHConfig.parse(path:Path) -> None

Parse an OpenSSH config file and return matching declarations

classasyncssh.config.SSHServerConfig

Settings from an OpenSSH server config file

classasyncssh.crypto.chacha.ChachaCipher

Shim for Chacha20-Poly1305 symmetric encryption

methodasyncssh.crypto.chacha.ChachaCipher.decrypt_header(header:bytes, nonce:bytes) -> bytes

Decrypt header data

methodasyncssh.crypto.chacha.ChachaCipher.encrypt_and_sign(header:bytes, data:bytes, nonce:bytes) -> Tuple[bytes, bytes]

Encrypt and sign a block of data

method

asyncssh.crypto.chacha.ChachaCipher.verify_and_decrypt(header:bytes, data:bytes, nonce:bytes, tag:bytes) -> Optional[bytes]

Verify the signature of and decrypt a block of data

funcasyncssh.crypto.chacha.chacha20(key:bytes, data:bytes, nonce:bytes, ctr:int) -> bytes

Encrypt/decrypt a block of data with the ChaCha20 cipher

funcasyncssh.crypto.chacha.poly1305(key:bytes, data:bytes, nonce:bytes) -> bytes

Compute a Poly1305 tag for a block of data

funcasyncssh.crypto.chacha.poly1305_key(key:bytes, nonce:bytes) -> bytes

Derive a Poly1305 key

funcasyncssh.crypto.chacha.poly1305_verify(key:bytes, data:bytes, nonce:bytes, tag:bytes) -> bool

Verify a Poly1305 tag for a block of data

classasyncssh.crypto.cipher.BasicCipher

Shim for basic ciphers

methodasyncssh.crypto.cipher.BasicCipher.decrypt(data:bytes) -> bytes

Decrypt a block of data

methodasyncssh.crypto.cipher.BasicCipher.encrypt(data:bytes) -> bytes

Encrypt a block of data

classasyncssh.crypto.cipher.GCMCipher

Shim for GCM ciphers

methodasyncssh.crypto.cipher.GCMCipher.encrypt_and_sign(header:bytes, data:bytes) -> Tuple[bytes, bytes]

Encrypt and sign a block of data

methodasyncssh.crypto.cipher.GCMCipher.verify_and_decrypt(header:bytes, data:bytes, mac:bytes) -> Optional[bytes]

Verify the signature of and decrypt a block of data

funcasyncssh.crypto.cipher.get_cipher_params(cipher_name:str) -> _CipherParams

Get parameters of a symmetric cipher

funcasyncssh.crypto.cipher.register_cipher(cipher_name:str, key_size:int, iv_size:int, block_size:int) -> None

classasyncssh.crypto.dh.DH

A shim around PyCA for Diffie Hellman key exchange

methodasyncssh.crypto.dh.DH.get_public() -> int

Return the public key to send in the handshake

methodasyncssh.crypto.dh.DH.get_shared(peer_public:int) -> int

Return the shared key from the peer's public key

classasyncssh.crypto.dsa.DSAPrivateKey

A shim around PyCA for DSA private keys

methodasyncssh.crypto.dsa.DSAPrivateKey.construct(p:int, q:int, g:int, y:int, x:int) -> 'DSAPrivateKey'

Construct a DSA private key

methodasyncssh.crypto.dsa.DSAPrivateKey.generate(key_size:int) -> 'DSAPrivateKey'

Generate a new DSA private key

methodasyncssh.crypto.dsa.DSAPrivateKey.sign(data:bytes, hash_name:str='') -> bytes

Sign a block of data

classasyncssh.crypto.dsa.DSAPublicKey

A shim around PyCA for DSA public keys

methodasyncssh.crypto.dsa.DSAPublicKey.construct(p:int, q:int, g:int, y:int) -> 'DSAPublicKey'

Construct a DSA public key

methodasyncssh.crypto.dsa.DSAPublicKey.verify(data:bytes, sig:bytes, hash_name:str='') -> bool

Verify the signature on a block of data

classasyncssh.crypto.ec.ECDH

A shim around PyCA for ECDH key exchange

methodasyncssh.crypto.ec.ECDH.get_public() -> bytes

Return the public key to send in the handshake

methodasyncssh.crypto.ec.ECDH.get_shared(peer_public:bytes) -> int

Return the shared key from the peer's public key

methodasyncssh.crypto.ec.ECDH.get_shared_bytes(peer_public:bytes) -> bytes

Return the shared key from the peer's public key as bytes

classasyncssh.crypto.ec.ECDSAPrivateKey

A shim around PyCA for ECDSA private keys

methodasyncssh.crypto.ec.ECDSAPrivateKey.construct(curve_id:bytes, public_value:bytes, private_value:int) -> 'ECDSAPrivateKey'

Construct an ECDSA private key

methodasyncssh.crypto.ec.ECDSAPrivateKey.generate(curve_id:bytes) -> 'ECDSAPrivateKey'

Generate a new ECDSA private key

methodasyncssh.crypto.ec.ECDSAPrivateKey.sign(data:bytes, hash_name:str='') -> bytes

Sign a block of data

classasyncssh.crypto.ec.ECDSAPublicKey

A shim around PyCA for ECDSA public keys

methodasyncssh.crypto.ec.ECDSAPublicKey.construct(curve_id:bytes, public_value:bytes) -> 'ECDSAPublicKey'

Construct an ECDSA public key

methodasyncssh.crypto.ec.ECDSAPublicKey.verify(data:bytes, sig:bytes, hash_name:str='') -> bool

Verify the signature on a block of data

classasyncssh.crypto.ed.Curve25519DH

Curve25519 Diffie Hellman implementation based on PyCA

methodasyncssh.crypto.ed.Curve25519DH.get_public() -> bytes

Return the public key to send in the handshake

methodasyncssh.crypto.ed.Curve25519DH.get_shared(peer_public:bytes) -> int

Return the shared key from the peer's public key

methodasyncssh.crypto.ed.Curve25519DH.get_shared_bytes(peer_public:bytes) -> bytes

Return the shared key from the peer's public key as bytes

classasyncssh.crypto.ed.Curve448DH

Curve448 Diffie Hellman implementation based on PyCA

methodasyncssh.crypto.ed.Curve448DH.get_public() -> bytes

Return the public key to send in the handshake

methodasyncssh.crypto.ed.Curve448DH.get_shared(peer_public:bytes) -> int

Return the shared key from the peer's public key

classasyncssh.crypto.ed.EdDSAPrivateKey

A shim around PyCA for EdDSA private keys

methodasyncssh.crypto.ed.EdDSAPrivateKey.construct(curve_id:bytes, priv:bytes) -> 'EdDSAPrivateKey'

Construct an EdDSA private key

methodasyncssh.crypto.ed.EdDSAPrivateKey.generate(curve_id:bytes) -> 'EdDSAPrivateKey'

Generate a new EdDSA private key

methodasyncssh.crypto.ed.EdDSAPrivateKey.sign(data:bytes, hash_name:str='') -> bytes

Sign a block of data

classasyncssh.crypto.ed.EdDSAPublicKey

A shim around PyCA for EdDSA public keys

methodasyncssh.crypto.ed.EdDSAPublicKey.construct(curve_id:bytes, pub:bytes) -> 'EdDSAPublicKey'

Construct an EdDSA public key

methodasyncssh.crypto.ed.EdDSAPublicKey.verify(data:bytes, sig:bytes, hash_name:str='') -> bool

Verify the signature on a block of data

funcasyncssh.crypto.kdf.pbkdf2_hmac(hash_name:str, passphrase:bytes, salt:bytes, count:int, key_size:int) -> bytes

A shim around PyCA for PBKDF2 HMAC key derivation

classasyncssh.crypto.misc.CryptoKey

Base class for PyCA private/public keys

methodasyncssh.crypto.misc.CryptoKey.pyca_key() -> PyCAKey

Return the PyCA object associated with this key

methodasyncssh.crypto.misc.CryptoKey.sign(data:bytes, hash_name:str='') -> bytes

Sign a block of data

methodasyncssh.crypto.misc.CryptoKey.verify(data:bytes, sig:bytes, hash_name:str='') -> bool

Verify the signature on a block of data

classasyncssh.crypto.pq.PQKey

Protocol for performing post-quantum key exchange

methodasyncssh.crypto.pq.PQKey.decaps(ciphertext:bytes) -> bytes

Decrypt an encrypted secret using a private key

methodasyncssh.crypto.pq.PQKey.encaps(peer_public:bytes) -> Tuple[bytes, bytes]

Generate a random secret and encrypt it with a public key

methodasyncssh.crypto.pq.PQKey.get_public() -> bytes

Return the public key to send in the handshake

classasyncssh.crypto.rsa.RSAPrivateKey

A shim around PyCA for RSA private keys

method

asyncssh.crypto.rsa.RSAPrivateKey.construct(n:int, e:int, d:int, p:int, q:int, dmp1:int, dmq1:int, iqmp:int, skip_validation:bool) -> 'RSAPrivateKey'

Construct an RSA private key

methodasyncssh.crypto.rsa.RSAPrivateKey.decrypt(data:bytes, hash_name:str) -> Optional[bytes]

Decrypt a block of data

methodasyncssh.crypto.rsa.RSAPrivateKey.generate(key_size:int, exponent:int) -> 'RSAPrivateKey'

Generate a new RSA private key

methodasyncssh.crypto.rsa.RSAPrivateKey.sign(data:bytes, hash_name:str='') -> bytes

Sign a block of data

classasyncssh.crypto.rsa.RSAPublicKey

A shim around PyCA for RSA public keys

methodasyncssh.crypto.rsa.RSAPublicKey.construct(n:int, e:int) -> 'RSAPublicKey'

Construct an RSA public key

methodasyncssh.crypto.rsa.RSAPublicKey.encrypt(data:bytes, hash_name:str) -> Optional[bytes]

Encrypt a block of data

methodasyncssh.crypto.rsa.RSAPublicKey.verify(data:bytes, sig:bytes, hash_name:str='') -> bool

Verify the signature on a block of data

classasyncssh.crypto.x509.X509Certificate

A shim around PyCA and PyOpenSSL for X.509 certificates

method

asyncssh.crypto.x509.X509Certificate.validate(trust_store:Sequence['X509Certificate'], purposes:_Purposes, user_principal:str, host_principal:str) -> None

Validate an X.509 certificate

classasyncssh.crypto.x509.X509Name

A shim around PyCA for X.509 distinguished names

classasyncssh.crypto.x509.X509NamePattern

Match X.509 distinguished names

methodasyncssh.crypto.x509.X509NamePattern.matches(name:X509Name) -> bool

Return whether an X.509 name matches this pattern

funcasyncssh.crypto.x509.import_x509_certificate(data:bytes) -> X509Certificate

Construct an X.509 certificate from DER data

classasyncssh.editor.SSHLineEditor

Input line editor

methodasyncssh.editor.SSHLineEditor.process_input(data:str, datatype:DataType) -> None

Process input from channel

methodasyncssh.editor.SSHLineEditor.process_output(data:str) -> None

Process output to channel

methodasyncssh.editor.SSHLineEditor.register_key(key:str, handler:_KeyHandler) -> None

methodasyncssh.editor.SSHLineEditor.set_echo(echo:bool) -> None

Enable/disable echoing of input in line mode

methodasyncssh.editor.SSHLineEditor.set_input(line:str, pos:int) -> None

Set input line and cursor position

methodasyncssh.editor.SSHLineEditor.set_line_mode(line_mode:bool) -> None

Enable/disable input line editing

methodasyncssh.editor.SSHLineEditor.set_width(width:int) -> None

Set terminal line width

methodasyncssh.editor.SSHLineEditor.unregister_key(key:str) -> None

Remove the handler associated with a key

classasyncssh.editor.SSHLineEditorSession

Input line editor session wrapper

methodasyncssh.editor.SSHLineEditorSession.data_received(data:str, datatype:DataType) -> None

Process data received from the channel

methodasyncssh.editor.SSHLineEditorSession.eof_received() -> Optional[bool]

Process EOF received from the channel

methodasyncssh.editor.SSHLineEditorSession.session_started() -> None

Start a session for this newly opened server channel

methodasyncssh.editor.SSHLineEditorSession.terminal_size_changed(width:int, height:int, pixwidth:int, pixheight:int) -> None

The terminal size has changed

classasyncssh.encryption.BasicEncryption

Shim for basic encryption

methodasyncssh.encryption.BasicEncryption.decrypt_header(seq:int, first_block:bytes, header_len:int) -> Tuple[bytes, bytes]

Decrypt an SSH packet header

method

asyncssh.encryption.BasicEncryption.decrypt_packet(seq:int, first:bytes, rest:bytes, header_len:int, mac:bytes) -> Optional[bytes]

Verify the signature of and decrypt an SSH packet

methodasyncssh.encryption.BasicEncryption.encrypt_packet(seq:int, header:bytes, packet:bytes) -> Tuple[bytes, bytes]

Encrypt and sign an SSH packet

classasyncssh.encryption.ChachaEncryption

Shim for chacha20-poly1305 encryption

methodasyncssh.encryption.ChachaEncryption.decrypt_header(seq:int, first_block:bytes, header_len:int) -> Tuple[bytes, bytes]

Decrypt an SSH packet header

method

asyncssh.encryption.ChachaEncryption.decrypt_packet(seq:int, first:bytes, rest:bytes, header_len:int, mac:bytes) -> Optional[bytes]

Verify the signature of and decrypt an SSH packet

methodasyncssh.encryption.ChachaEncryption.encrypt_packet(seq:int, header:bytes, packet:bytes) -> Tuple[bytes, bytes]

Encrypt and sign an SSH packet

classasyncssh.encryption.ETMEncryption

Shim for encrypt-then-mac encryption

methodasyncssh.encryption.ETMEncryption.decrypt_header(seq:int, first_block:bytes, header_len:int) -> Tuple[bytes, bytes]

Decrypt an SSH packet header

method

asyncssh.encryption.ETMEncryption.decrypt_packet(seq:int, first:bytes, rest:bytes, header_len:int, mac:bytes) -> Optional[bytes]

Verify the signature of and decrypt an SSH packet

methodasyncssh.encryption.ETMEncryption.encrypt_packet(seq:int, header:bytes, packet:bytes) -> Tuple[bytes, bytes]

Encrypt and sign an SSH packet

classasyncssh.encryption.Encryption

Parent class for SSH packet encryption objects

methodasyncssh.encryption.Encryption.decrypt_header(seq:int, first_block:bytes, header_len:int) -> Tuple[bytes, bytes]

Decrypt an SSH packet header

method

asyncssh.encryption.Encryption.decrypt_packet(seq:int, first:bytes, rest:bytes, header_len:int, mac:bytes) -> Optional[bytes]

Verify the signature of and decrypt an SSH packet

methodasyncssh.encryption.Encryption.encrypt_packet(seq:int, header:bytes, packet:bytes) -> Tuple[bytes, bytes]

Encrypt and sign an SSH packet

methodasyncssh.encryption.Encryption.get_mac_params(mac_alg:bytes) -> Tuple[int, int, bool]

Get parameters of the MAC algorithm used with this encryption

methodasyncssh.encryption.Encryption.needs_mac() -> bool

Return whether a MAC algorithm is needed for this encryption

method

asyncssh.encryption.Encryption.new(cipher_name:str, key:bytes, iv:bytes, mac_alg:bytes=b'', mac_key:bytes=b'', etm:bool=False) -> 'Encryption'

Construct a new SSH packet encryption object

classasyncssh.encryption.GCMEncryption

Shim for GCM encryption

methodasyncssh.encryption.GCMEncryption.decrypt_header(seq:int, first_block:bytes, header_len:int) -> Tuple[bytes, bytes]

Decrypt an SSH packet header

method

asyncssh.encryption.GCMEncryption.decrypt_packet(seq:int, first:bytes, rest:bytes, header_len:int, mac:bytes) -> Optional[bytes]

Verify the signature of and decrypt an SSH packet

methodasyncssh.encryption.GCMEncryption.encrypt_packet(seq:int, header:bytes, packet:bytes) -> Tuple[bytes, bytes]

Encrypt and sign an SSH packet

methodasyncssh.encryption.GCMEncryption.get_mac_params(mac_alg:bytes) -> Tuple[int, int, bool]

Get parameters of the MAC algorithm used with this encryption

methodasyncssh.encryption.GCMEncryption.needs_mac() -> bool

GCM encryption doesn't need an external MAC algorithm

funcasyncssh.encryption.encryption_needs_mac(enc_alg:bytes) -> bool

Return whether an encryption algorithm needs a MAC algorithm

funcasyncssh.encryption.get_default_encryption_algs() -> List[bytes]

Return default encryption algorithms

funcasyncssh.encryption.get_encryption_algs() -> List[bytes]

Return supported encryption algorithms

funcasyncssh.encryption.get_encryption_params(enc_alg:bytes, mac_alg:bytes=b'') -> _EncParams

Get parameters of an encryption and MAC algorithm

func

asyncssh.encryption.register_encryption_alg(enc_alg:bytes, encryption:Type[Encryption], cipher_name:str, default:bool) -> None

classasyncssh.forward.SSHForwarder

SSH port forwarding connection handler

methodasyncssh.forward.SSHForwarder.close() -> None

Close this port forwarder

methodasyncssh.forward.SSHForwarder.connection_lost(exc:Optional[Exception]) -> None

Handle an incoming connection close

methodasyncssh.forward.SSHForwarder.connection_made(transport:asyncio.BaseTransport) -> None

Handle a newly opened connection

methodasyncssh.forward.SSHForwarder.data_received(data:bytes, datatype:Optional[int]=None) -> None

Handle incoming data from the transport

methodasyncssh.forward.SSHForwarder.eof_received() -> bool

Handle an incoming end of file from the transport

methodasyncssh.forward.SSHForwarder.pause_reading() -> None

Pause reading from the transport

methodasyncssh.forward.SSHForwarder.pause_writing() -> None

Pause writing by asking peer to pause reading

methodasyncssh.forward.SSHForwarder.resume_reading() -> None

Resume reading on the transport

methodasyncssh.forward.SSHForwarder.resume_writing() -> None

Resume writing by asking peer to resume reading

methodasyncssh.forward.SSHForwarder.session_started() -> None

Handle session start

methodasyncssh.forward.SSHForwarder.set_peer(peer:'SSHForwarder') -> None

Set the peer forwarder to exchange data with

methodasyncssh.forward.SSHForwarder.was_eof_received() -> bool

Return whether end of file has been received or not

methodasyncssh.forward.SSHForwarder.write(data:bytes) -> None

Write data to the transport

methodasyncssh.forward.SSHForwarder.write_eof() -> None

Write end of file to the transport

classasyncssh.forward.SSHLocalForwarder

Local forwarding connection handler

methodasyncssh.forward.SSHLocalForwarder.forward(*args:object) -> None

Start a task to begin local forwarding

funcasyncssh.forward.SSHLocalForwarder.session_factory() -> SSHForwarder

Return an SSH forwarder

classasyncssh.forward.SSHLocalPathForwarder

Local UNIX domain socket forwarding connection handler

methodasyncssh.forward.SSHLocalPathForwarder.connection_made(transport:asyncio.BaseTransport) -> None

Handle a newly opened connection

classasyncssh.forward.SSHLocalPortForwarder

Local TCP port forwarding connection handler

methodasyncssh.forward.SSHLocalPortForwarder.connection_made(transport:asyncio.BaseTransport) -> None

Handle a newly opened connection

classasyncssh.gss.GSSBase

Base class for reporting that GSS is not available

classasyncssh.gss.GSSClient

Stub client class for reporting that GSS is not available

classasyncssh.gss.GSSError

Stub class for reporting that GSS is not available

classasyncssh.gss.GSSServer

Stub client class for reporting that GSS is not available

classasyncssh.gss_unix.GSSBase

GSS base class

methodasyncssh.gss_unix.GSSBase.complete() -> bool

Return whether or not GSS negotiation is complete

methodasyncssh.gss_unix.GSSBase.host() -> str

Return host principal associated with this context

methodasyncssh.gss_unix.GSSBase.mechs() -> Sequence[bytes]

Return GSS mechanisms available for this host

methodasyncssh.gss_unix.GSSBase.reset() -> None

Reset GSS security context

methodasyncssh.gss_unix.GSSBase.sign(data:bytes) -> bytes

Sign a block of data

methodasyncssh.gss_unix.GSSBase.step(token:Optional[bytes]=None) -> Optional[bytes]

Perform next step in GSS security exchange

methodasyncssh.gss_unix.GSSBase.user() -> str

Return user principal associated with this context

methodasyncssh.gss_unix.GSSBase.verify(data:bytes, sig:bytes) -> bool

Verify a signature for a block of data

classasyncssh.gss_unix.GSSClient

GSS client

classasyncssh.gss_unix.GSSServer

GSS server

classasyncssh.gss_win32.GSSBase

GSS base class

methodasyncssh.gss_win32.GSSBase.complete() -> bool

Return whether or not GSS negotiation is complete

methodasyncssh.gss_win32.GSSBase.host() -> str

Return host principal associated with this context

methodasyncssh.gss_win32.GSSBase.mechs() -> Sequence[bytes]

Return GSS mechanisms available for this host

methodasyncssh.gss_win32.GSSBase.reset() -> None

Reset GSS security context

methodasyncssh.gss_win32.GSSBase.sign(data:bytes) -> bytes

Sign a block of data

methodasyncssh.gss_win32.GSSBase.step(token:Optional[bytes]=None) -> Optional[bytes]

Perform next step in GSS security exchange

methodasyncssh.gss_win32.GSSBase.user() -> str

Return user principal associated with this context

methodasyncssh.gss_win32.GSSBase.verify(data:bytes, sig:bytes) -> bool

Verify a signature for a block of data

classasyncssh.gss_win32.GSSClient

GSS client

classasyncssh.gss_win32.GSSError

Class for reporting GSS errors

classasyncssh.gss_win32.GSSServer

GSS server

classasyncssh.kex.Kex

Parent class for key exchange handlers

methodasyncssh.kex.Kex.compute_key(k:bytes, h:bytes, x:bytes, session_id:bytes, keylen:int) -> bytes

Compute keys from output of key exchange

methodasyncssh.kex.Kex.logger() -> SSHLogger

A logger associated with this connection

methodasyncssh.kex.Kex.send_packet(pkttype:int, *args:bytes) -> None

Send a kex packet

methodasyncssh.kex.Kex.start() -> None

Start key exchange

funcasyncssh.kex.get_default_kex_algs() -> List[bytes]

Return default key exchange algorithms

funcasyncssh.kex.get_kex_algs() -> List[bytes]

Return supported key exchange algorithms

funcasyncssh.kex.register_gss_kex_alg(alg:bytes, handler:Type[Kex], hash_alg:HashType, args:Tuple, default:bool) -> None

funcasyncssh.kex.register_kex_alg(alg:bytes, handler:Type[Kex], hash_alg:HashType, args:Tuple, default:bool) -> None

classasyncssh.keysign.SSHKeySignKeyPair

Surrogate for a key where signing is done via ssh-keysign

methodasyncssh.keysign.SSHKeySignKeyPair.sign_async(data:bytes) -> bytes

Use ssh-keysign to sign a block of data with this key

funcasyncssh.keysign.find_keysign(path:KeySignPath) -> str

Return path to ssh-keysign executable

func

asyncssh.keysign.get_keysign_keys(keysign_path:str, sock_fd:int, keys:Iterable[_KeySignKey]) -> Sequence[SSHKeySignKeyPair]

Return keypair objects which invoke ssh-keysign

classasyncssh.known_hosts.SSHKnownHosts

An SSH known hosts list

methodasyncssh.known_hosts.SSHKnownHosts.load(known_hosts:str) -> None

Load known hosts data into this object

classasyncssh.listener.SSHClientListener

Client listener used to accept inbound forwarded connections

methodasyncssh.listener.SSHClientListener.close() -> None

Close this listener asynchronously

methodasyncssh.listener.SSHClientListener.wait_closed() -> None

Wait for this listener to finish closing

classasyncssh.listener.SSHForwardListener

A listener used when forwarding traffic from local ports

methodasyncssh.listener.SSHForwardListener.close() -> None

Close this listener

methodasyncssh.listener.SSHForwardListener.get_port() -> int

Return the port number being listened on

methodasyncssh.listener.SSHForwardListener.wait_closed() -> None

Wait for this listener to finish closing

classasyncssh.listener.SSHListener

SSH listener for inbound connections

methodasyncssh.listener.SSHListener.set_tunnel(tunnel:'SSHConnection') -> None

Set tunnel associated with listener

funcasyncssh.listener.protocol_factory() -> asyncio.BaseProtocol

Start a port forwarder for each new local connection

classasyncssh.logging.SSHLogger

Adapter to add context to AsyncSSH log messages

methodasyncssh.logging.SSHLogger.debug1(msg:str, *args:_LogArg, **kwargs:object) -> None

Write a level 1 debug log message

methodasyncssh.logging.SSHLogger.debug2(msg:str, *args:_LogArg, **kwargs:object) -> None

Write a level 2 debug log message

methodasyncssh.logging.SSHLogger.get_child(child:str='', context:str='') -> 'SSHLogger'

Return child logger with optional added context

methodasyncssh.logging.SSHLogger.log(level:int, msg:object, *args, **kwargs) -> None

Log a message to the underlying logger

methodasyncssh.logging.SSHLogger.packet(pktid:Optional[int], packet:bytes, msg:str, *args:_LogArg, **kwargs:object) -> None

Write a control packet debug log message

methodasyncssh.logging.SSHLogger.process(msg:str, kwargs:_ObjDict) -> Tuple[str, _ObjDict]

Add context to log message

methodasyncssh.logging.SSHLogger.set_debug_level(level:int) -> None

Set AsyncSSH debug log level

classasyncssh.mac.MAC

Parent class for SSH message authentication handlers

methodasyncssh.mac.MAC.sign(seq:int, packet:bytes) -> bytes

Compute a signature for a message

methodasyncssh.mac.MAC.verify(seq:int, packet:bytes, sig:bytes) -> bool

Verify the signature of a message

funcasyncssh.mac.get_default_mac_algs() -> List[bytes]

Return default MAC algorithms

funcasyncssh.mac.get_mac_algs() -> List[bytes]

Return supported MAC algorithms

func

asyncssh.mac.register_mac_alg(mac_alg:bytes, key_size:int, hash_size:int, etm:bool, handler:Callable, args:Tuple, default:bool) -> None

classasyncssh.misc.Error

General SSH error

classasyncssh.misc.HashType

Protocol for returning the type of a hash function

classasyncssh.misc.Options

Container for configuration options

methodasyncssh.misc.Options.prepare(**kwargs:object) -> None

Pre-process configuration options

methodasyncssh.misc.Options.update(**kwargs:object) -> None

Update options based on keyword parameters passed in

classasyncssh.misc.OptionsParser

Parser for comma-separated key-value pairs with quoting

classasyncssh.misc.Record

Generic Record class

funcasyncssh.misc.all_ints(seq:Sequence[object]) -> bool

Return if a sequence contains all integers

funcasyncssh.misc.decode_env(env:Dict[bytes, bytes]) -> Iterator[Tuple[str, str]]

Convert bytes-based environment dict to Unicode strings

funcasyncssh.misc.encode_env(env:Env) -> Iterator[Tuple[bytes, bytes]]

Convert environment dict or list to bytes-based dictionary

funcasyncssh.misc.get_symbol_names(symbols:Mapping[str, int], prefix:str, strip_leading:int=0) -> Mapping[int, str]

Return a mapping from values to symbol names for logging

funcasyncssh.misc.hide_empty(value:object, prefix:str=', ') -> str

Return a string with optional prefix if value is non-empty

funcasyncssh.misc.ip_address(addr:str) -> IPAddress

Wrapper for ipaddress.ip_address which supports scoped addresses

funcasyncssh.misc.ip_network(addr:str) -> IPNetwork

Wrapper for ipaddress.ip_network which supports scoped addresses

funcasyncssh.misc.lookup_env(patterns:EnvSeq) -> Iterator[Tuple[bytes, bytes]]

Look up environment variables with wildcard matches

funcasyncssh.misc.make_sparse_file(file_obj:IO) -> None

Enable sparse file support on a file on Windows

funcasyncssh.misc.map_handler_name(name:str) -> str

Map punctuation so a string can be used as a handler name

funcasyncssh.misc.match_base64(data:bytes, start:int, header:bytes) -> Tuple[bytes, int]

Match a block of base64 data wrapped in a header/footer

funcasyncssh.misc.open_file(filename:FilePath, mode:str, buffering:int=-1) -> IO[bytes]

Open a file with home directory expansion

funcasyncssh.misc.parse_byte_count(value:str) -> int

Parse a byte count with optional k, m, or g suffixes

funcasyncssh.misc.parse_time(t:AbsTime) -> int

Parse a time value

funcasyncssh.misc.parse_time_interval(value:str) -> float

Parse a time interval with optional s, m, h, d, or w suffixes

funcasyncssh.misc.plural(length:int, label:str, suffix:str='s') -> str

Return a label with an optional plural suffix

funcasyncssh.misc.read_file(filename:FilePath) -> bytes

Read from a binary file with home directory expansion

funcasyncssh.misc.run_in_executor(func:Callable[..., _T], *args:object) -> _T

Run a function in an asyncio executor

funcasyncssh.misc.set_terminal_size(tty:IO, width:int, height:int, pixwidth:int, pixheight:int) -> None

Set the terminal size of a TTY

funcasyncssh.misc.split_args(command:str) -> Sequence[str]

Split a command string into a list of arguments

funcasyncssh.misc.write_file(filename:FilePath, data:bytes, mode:str='wb') -> int

Write or append to a file with home directory expansion

funcasyncssh.packet.Boolean(value:bool) -> bytes

Encode a boolean value

funcasyncssh.packet.Byte(value:int) -> bytes

Encode a single byte

funcasyncssh.packet.MPInt(value:int) -> bytes

Encode a multiple precision integer value

funcasyncssh.packet.NameList(value:Iterable[bytes]) -> bytes

Encode a comma-separated list of byte strings

classasyncssh.packet.PacketDecodeError

Packet decoding error

classasyncssh.packet.SSHPacket

Decoder class for SSH packets

methodasyncssh.packet.SSHPacket.check_end() -> None

Confirm that all of the data in the packet has been consumed

methodasyncssh.packet.SSHPacket.get_boolean() -> bool

Extract a boolean from the packet

methodasyncssh.packet.SSHPacket.get_byte() -> int

Extract a single byte from the packet

methodasyncssh.packet.SSHPacket.get_bytes(size:int) -> bytes

Extract the requested number of bytes from the packet

methodasyncssh.packet.SSHPacket.get_consumed_payload() -> bytes

Return the portion of the packet consumed so far

methodasyncssh.packet.SSHPacket.get_full_payload() -> bytes

Return the full packet

methodasyncssh.packet.SSHPacket.get_mpint() -> int

Extract a multiple precision integer from the packet

methodasyncssh.packet.SSHPacket.get_remaining_payload() -> bytes

Return the portion of the packet not yet consumed

methodasyncssh.packet.SSHPacket.get_string() -> bytes

Extract a UTF-8 string from the packet

methodasyncssh.packet.SSHPacket.get_uint16() -> int

Extract a 16-bit integer from the packet

methodasyncssh.packet.SSHPacket.get_uint32() -> int

Extract a 32-bit integer from the packet

methodasyncssh.packet.SSHPacket.get_uint64() -> int

Extract a 64-bit integer from the packet

classasyncssh.packet.SSHPacketHandler

Parent class for SSH packet handlers

methodasyncssh.packet.SSHPacketHandler.logger() -> SSHLogger

The logger associated with this packet handler

method

asyncssh.packet.SSHPacketHandler.process_packet(pkttype:int, pktid:int, packet:SSHPacket) -> Union[bool, Awaitable[None]]

Log and process a received packet

classasyncssh.packet.SSHPacketLogger

Parent class for SSH packet loggers

method

asyncssh.packet.SSHPacketLogger.log_received_packet(pkttype:int, pktid:Optional[int], packet:_LoggedPacket, note:str='') -> None

Log a received packet

method

asyncssh.packet.SSHPacketLogger.log_sent_packet(pkttype:int, pktid:Optional[int], packet:_LoggedPacket, note:str='') -> None

Log a sent packet

methodasyncssh.packet.SSHPacketLogger.logger() -> SSHLogger

The logger to use for packet logging

funcasyncssh.packet.String(value:Union[bytes, str]) -> bytes

Encode a byte string or UTF-8 string value

funcasyncssh.packet.UInt16(value:int) -> bytes

Encode a 16-bit integer value

funcasyncssh.packet.UInt32(value:int) -> bytes

Encode a 32-bit integer value

funcasyncssh.packet.UInt64(value:int) -> bytes

Encode a 64-bit integer value

classasyncssh.pattern.CIDRHostPattern

Match IPv4/v6 address against CIDR-style subnet pattern

methodasyncssh.pattern.CIDRHostPattern.matches(_host:str, _addr:str, ip:IPAddress) -> bool

Return whether an IP address matches a CIDR address pattern

classasyncssh.pattern.HostPatternList

Match host names & addresses against wildcard and CIDR patterns

methodasyncssh.pattern.HostPatternList.build_pattern(pattern:str) -> _HostPattern

Build a CIDR address or wild card host pattern

classasyncssh.pattern.WildcardHostPattern

Match a host name or address against a wildcard pattern

classasyncssh.pattern.WildcardPattern

A pattern matcher for '*' and '?' wildcards

methodasyncssh.pattern.WildcardPattern.matches(value:str) -> bool

Return whether a wild card pattern matches a value

classasyncssh.pattern.WildcardPatternList

Match names against wildcard patterns

methodasyncssh.pattern.WildcardPatternList.build_pattern(pattern:str) -> WildcardPattern

Build a wild card pattern

func

asyncssh.pbe.register_pbes2_cipher(pbes2_cipher_name:str, pbes2_cipher_oid:ObjectIdentifier, handler:_PBES2CipherHandler, cipher_name:str) -> None

funcasyncssh.pbe.register_pbes2_kdf(kdf_name:str, kdf_oid:ObjectIdentifier, handler:_PBES2KDFHandler, *args:object) -> None

funcasyncssh.pbe.register_pbes2_prf(hash_name:str, prf_oid:ObjectIdentifier) -> None

funcasyncssh.pbe.register_pkcs1_cipher(pkcs1_cipher_name:str, pkcs1_dek_name:bytes, cipher_name:str) -> None

classasyncssh.pkcs11.SSHPKCS11KeyPair

Surrogate for a key accessed via a PKCS#11 provider

methodasyncssh.pkcs11.SSHPKCS11KeyPair.sign(data:bytes) -> bytes

Sign a block of data with this private key

classasyncssh.pkcs11.SSHPKCS11Session

Work around PKCS#11 sessions not supporting simultaneous opens

methodasyncssh.pkcs11.SSHPKCS11Session.close() -> None

Drop one reference to an open session

method

asyncssh.pkcs11.SSHPKCS11Session.get_keys(load_certs:bool, key_label:Optional[str], key_id:Optional[BytesOrStr]) -> Sequence[SSHPKCS11KeyPair]

Return the private keys found on this token

methodasyncssh.pkcs11.SSHPKCS11Session.open(token:Token, pin:Optional[str]) -> 'SSHPKCS11Session'

Open a new session, or return an already-open one

classasyncssh.process.SSHClientProcess

SSH client process handler

methodasyncssh.process.SSHClientProcess.exit_signal() -> Optional[Tuple[str, bool, str, str]]

Exit signal information for the process

methodasyncssh.process.SSHClientProcess.exit_status() -> Optional[int]

The exit status of the process

methodasyncssh.process.SSHClientProcess.feed_exception(exc:Exception) -> None

Feed exception to the channel

method

asyncssh.process.SSHClientProcess.redirect_stderr(target:ProcessTarget, bufsize:int=io.DEFAULT_BUFFER_SIZE, recv_eof:bool=True) -> None

Redirect standard error of the process

method

asyncssh.process.SSHClientProcess.redirect_stdin(source:ProcessSource, bufsize:int=io.DEFAULT_BUFFER_SIZE, send_eof:bool=True) -> None

Redirect standard input of the process

method

asyncssh.process.SSHClientProcess.redirect_stdout(target:ProcessTarget, bufsize:int=io.DEFAULT_BUFFER_SIZE, recv_eof:bool=True) -> None

Redirect standard output of the process

methodasyncssh.process.SSHClientProcess.session_started() -> None

Start a process for this newly opened client channel

classasyncssh.process.SSHProcess

SSH process handler

この情報について

掲載しているシグネチャは ronf/asyncssh の公開ソースコードを Python の ast モジュールで静的解析し、引数名・デフォルト値・型注釈・戻り値型をそのまま抽出したものです。実装コードは保存していません。詳しくは仕組みの解説をご覧ください。

収録ライブラリ一覧（全 805 件）へ戻る