bssh-russh 0.60.1

Temporary fork of russh with high-frequency PTY output fix (Handle::data from spawned tasks)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

use ssh_encoding::Writer;

use super::{KexAlgorithm, KexAlgorithmImplementor, KexType};

pub struct NoneKexType {}

impl KexType for NoneKexType {
    fn make(&self) -> KexAlgorithm {
        NoneKexAlgorithm {}.into()
    }
}

#[doc(hidden)]
pub struct NoneKexAlgorithm {}

impl KexAlgorithmImplementor for NoneKexAlgorithm {
    fn skip_exchange(&self) -> bool {
        true
    }

    fn server_dh(
        &mut self,
        _exchange: &mut crate::session::Exchange,
        _payload: &[u8],
    ) -> Result<(), crate::Error> {
        Ok(())
    }

    fn client_dh(
        &mut self,
        _client_ephemeral: &mut Vec<u8>,
        _buf: &mut impl Writer,
    ) -> Result<(), crate::Error> {
        Ok(())
    }

    fn compute_shared_secret(&mut self, _remote_pubkey: &[u8]) -> Result<(), crate::Error> {
        Ok(())
    }

    fn shared_secret_bytes(&self) -> Option<&[u8]> {
        None
    }

    fn compute_exchange_hash(
        &self,
        _key: &[u8],
        _exchange: &crate::session::Exchange,
        _buffer: &mut russh_cryptovec::CryptoVec,
    ) -> Result<Vec<u8>, crate::Error> {
        Ok(Vec::new())
    }

    fn compute_keys(
        &self,
        session_id: &[u8],
        exchange_hash: &[u8],
        cipher: crate::cipher::Name,
        remote_to_local_mac: crate::mac::Name,
        local_to_remote_mac: crate::mac::Name,
        is_server: bool,
    ) -> Result<crate::cipher::CipherPair, crate::Error> {
        super::compute_keys::<sha2::Sha256>(
            None,
            session_id,
            exchange_hash,
            cipher,
            remote_to_local_mac,
            local_to_remote_mac,
            is_server,
        )
    }
}