pijul/thrussh - Change IVSHPDNR6PQRZGJXJLPG2AG5GOXQLAALKD6WWBE4XYUEGAB24EHAC

Create agent package, which generic over keys The main aim of this patch is to separate the agent code away from the specific key implementations. This required making the mention of keys in `agent/client.rs` and `agent/server.rs` generic. The logic that involved the keys is captured in a set of traits. All of this code now lives in `thrussh-agent`. A side-effect of this reorganisation was the carving out of `thrussh-encoding`. Since the the `encoding.rs` logic was standalone, it now lives in its own package, so that other dependencies can rely on it for implementing the agent's traits. The key types in `thrussh-keys` implement the agent's traits. The rest of the changes are fixing up the `thrussh-keys` and `thrussh` crates with the corresponding type changes, such as introducing `Error` enums and renaming of imports.

Created by fintohaps on August 16, 2021

IVSHPDNR6PQRZGJXJLPG2AG5GOXQLAALKD6WWBE4XYUEGAB24EHAC

Dependencies

In discussions

#47 Generic Agents

Change contents

Replacement in thrussh-keys/src/signature.rs at line 23 [7.5821]
B:BD[7.6430] → [7.6430:6469]
```
        use crate::encoding::Encoding;
```
[7.6430]
[7.6469]
```
        use thrussh_encoding::Encoding;
```
Replacement in thrussh-keys/src/signature.rs at line 55 [7.5821]
B:BD[7.7667] → [7.7667:7704]
```
        use crate::encoding::Reader;
```
[7.7667]
[7.7704]
```
        use thrussh_encoding::Reader;
```
Deletion in thrussh-keys/src/lib.rs at line 73 [7.21590]
B:BD[7.26115] → [7.26115:26133]
```
pub mod encoding;
```
Deletion in thrussh-keys/src/lib.rs at line 79 [7.21590]
B:BD[7.26230] → [7.26230:26279]
```
/// A module to write SSH agent.
pub mod agent;
```

Insertion in thrussh-keys/src/lib.rs at line 81 [7.21590]

[7.26320]

    #[error(transparent)]
    Client(#[from] thrussh_agent::client::Error),

Replacement in thrussh-keys/src/lib.rs at line 101 [7.21590]

B:BD[7.27019] → [7.27019:27105]

    /// Index out of bounds
    #[error("Index out of bounds")]
    IndexOutOfBounds,

[7.27019]

[7.27105]

    #[error(transparent)]
    Encoding(#[from] thrussh_encoding::Error),

Replacement in thrussh-keys/src/lib.rs at line 106 [7.21590]

B:BD[7.27236] → [7.27236:27374]

    /// Agent protocol error
    #[error("Agent protocol error")]
    AgentProtocolError,
    #[error("Agent failure")]
    AgentFailure,

[7.27236]

[8.59]

Deletion in thrussh-keys/src/lib.rs at line 121 [7.21590]

∅:D[9.28] → [10.0:53]

B:BD[8.360] → [10.0:53]

∅:D[10.53] → [8.407:433]

B:BD[8.407] → [8.407:433]

B:BD[8.433] → [11.0:154]

B:BD[11.154] → [11.154:171]

    #[error("Environment variable `{0}` not found")]
    EnvVar(&'static str),
    #[error("Unable to connect to ssh-agent. The environment variable `SSH_AUTH_SOCK` \
    was set, but it points to a nonexistent file or directory.")]
    BadAuthSock,

Replacement in thrussh-keys/src/lib.rs at line 187 [7.21590]

B:BD[7.29411] → [7.29411:29451]

                use encoding::Encoding;

[7.29411]

[2.157]

                use thrussh_encoding::Encoding;

Replacement in thrussh-keys/src/lib.rs at line 213 [7.21590]

B:BD[7.30175] → [7.30175:30215]

                use encoding::Encoding;

[7.30175]

[7.30215]

                use thrussh_encoding::Encoding;

Replacement in thrussh-keys/src/lib.rs at line 759 [7.21590]

B:BD[7.54693] → [7.54693:54767]

            let mut client = agent::client::AgentClient::connect(stream);

[7.54693]

[7.54767]

            let mut client = thrussh_agent::client::AgentClient::connect(stream);

Replacement in thrussh-keys/src/lib.rs at line 761 [7.21590]

B:BD[7.54818] → [7.54818:54866]

            client.request_identities().await?;

[7.54818]

[7.54866]

            client.request_identities::<key::PublicKey>().await?;

Replacement in thrussh-keys/src/lib.rs at line 809 [7.21590]
∅:D[12.2517] → [7.56004:56023]
B:BD[7.56004] → [7.56004:56023]
```
        use agent;
```
[12.2517]
[7.56023]
```
        use thrussh_agent as agent;
```

Replacement in thrussh-keys/src/lib.rs at line 813 [7.21590]

B:BD[7.56069] → [7.56069:56111]

        impl agent::server::Agent for X {

[7.56069]

[7.56111]

        impl agent::server::Agent<key::KeyPair> for X {

Replacement in thrussh-keys/src/lib.rs at line 841 [7.21590]

B:BD[7.57052] → [7.57052:57100]

            client.request_identities().await?;

[7.57052]

[7.57100]

            client.request_identities::<key::PublicKey>().await?;

Deletion in thrussh-keys/src/key.rs at line 15 [7.57451]
B:BD[7.58051] → [7.58051:58092]
```
use crate::encoding::{Encoding, Reader};
```
Insertion in thrussh-keys/src/key.rs at line 17 [7.57451]
[7.58139]
[7.58139]
```
use byteorder::{BigEndian, ByteOrder};
```

Insertion in thrussh-keys/src/key.rs at line 21 [7.57451]

[7.58203]

[12.2869]

use thrussh_agent::key as agent_key;
use thrussh_encoding::{Encoding, Position, Reader};

Replacement in thrussh-keys/src/key.rs at line 159 [7.57451]

B:BD[12.3613] → [12.3613:3723]

                    if key_algo != b"ssh-rsa" && key_algo != b"rsa-sha2-256" && key_algo != b"rsa-sha2-512" {

[12.3613]

[12.3723]

                    if key_algo != b"ssh-rsa"
                        && key_algo != b"rsa-sha2-256"
                        && key_algo != b"rsa-sha2-512"
                    {

Replacement in thrussh-keys/src/key.rs at line 227 [7.57451]
B:BD[7.64152] → [12.4933:4969]
```
        use sha2::{Sha256, Digest};
```
[7.64152]
[12.4969]
```
        use sha2::{Digest, Sha256};
```
Deletion in thrussh-keys/src/key.rs at line 233 [7.57451]
∅:D[12.5107] → [13.0:1]
B:BD[7.64234] → [13.0:1]
Replacement in thrussh-keys/src/key.rs at line 247 [7.57451]
B:BD[12.5185] → [12.5185:5233]
∅:D[12.5233] → [13.428:434]
B:BD[13.428] → [13.428:434]
```
    pub fn set_algorithm(&mut self, _: &[u8]) {
    }
```
[12.5185]
[7.64234]
```
    pub fn set_algorithm(&mut self, _: &[u8]) {}
```
Replacement in thrussh-keys/src/key.rs at line 283 [7.57451]
B:BD[7.65081] → [7.65081:65131]
```
impl<'b> crate::encoding::Bytes for &'b KeyPair {
```
[7.65081]
[7.65131]
```
impl<'b> thrussh_encoding::Bytes for &'b KeyPair {
```
Replacement in thrussh-keys/src/key.rs at line 306 [7.57451]
B:BD[7.65879] → [12.5349:5380]
```
                    .unwrap();
```
[7.65879]
[7.65906]
```
                .unwrap();
```

Insertion in thrussh-keys/src/key.rs at line 464 [7.57451]

[7.71316]

}
impl agent_key::Signature for Signature {
    type Error = Error;
    fn read(buf: &CryptoVec) -> Result<Self, Self::Error> {
        let mut r = buf.reader(1);
        let mut resp = r.read_string()?.reader(0);
        let typ = resp.read_string()?;
        let sig = resp.read_string()?;
        match typ {
            b"rsa-sha2-256" => Ok(Signature::RSA {
                bytes: sig.to_vec(),
                hash: SignatureHash::SHA2_256,
            }),
            b"rsa-sha2-512" => Ok(Signature::RSA {
                bytes: sig.to_vec(),
                hash: SignatureHash::SHA2_512,
            }),
            b"ssh-ed25519" => {
                let mut sig_bytes = [0; 64];
                sig_bytes.clone_from_slice(sig);
                Ok(Signature::Ed25519(crate::signature::SignatureBytes(
                    sig_bytes,
                )))
            }
            _ => Err((Error::UnknownSignatureType {
                sig_type: std::str::from_utf8(typ).unwrap_or("").to_string(),
            })
            .into()),
        }
    }
}
impl agent_key::Private for KeyPair {
    type Error = Error;
    fn read(r: &mut Position) -> Result<Option<(Vec<u8>, Self)>, Self::Error> {
        let t = r.read_string()?;
        match t {
            b"ssh-ed25519" => {
                let public_ = r.read_string()?;
                let concat = r.read_string()?;
                let _comment = r.read_string()?;
                if &concat[32..64] != public_ {
                    return Ok(None);
                }
                let mut public = ed25519::PublicKey::new_zeroed();
                let mut secret = ed25519::SecretKey::new_zeroed();
                public.key.clone_from_slice(&public_[..32]);
                secret.key.clone_from_slice(&concat[..]);
                Ok(Some((public_.to_vec(), KeyPair::Ed25519(secret))))
            }
            #[cfg(feature = "openssl")]
            b"ssh-rsa" => {
                use openssl::bn::{BigNum, BigNumContext};
                use openssl::rsa::Rsa;
                let n = r.read_mpint()?;
                let e = r.read_mpint()?;
                let d = BigNum::from_slice(r.read_mpint()?)?;
                let q_inv = r.read_mpint()?;
                let p = BigNum::from_slice(r.read_mpint()?)?;
                let q = BigNum::from_slice(r.read_mpint()?)?;
                let (dp, dq) = {
                    let one = BigNum::from_u32(1)?;
                    let p1 = p.as_ref() - one.as_ref();
                    let q1 = q.as_ref() - one.as_ref();
                    let mut context = BigNumContext::new()?;
                    let mut dp = BigNum::new()?;
                    let mut dq = BigNum::new()?;
                    dp.checked_rem(&d, &p1, &mut context)?;
                    dq.checked_rem(&d, &q1, &mut context)?;
                    (dp, dq)
                };
                let _comment = r.read_string()?;
                let key = Rsa::from_private_components(
                    BigNum::from_slice(n)?,
                    BigNum::from_slice(e)?,
                    d,
                    p,
                    q,
                    dp,
                    dq,
                    BigNum::from_slice(&q_inv)?,
                )?;
                let mut buf = CryptoVec::new();
                buf.extend_ssh_string(b"ssh-rsa");
                buf.extend_ssh_mpint(&e);
                buf.extend_ssh_mpint(&n);
                let blob = buf.to_vec();
                Ok(Some((
                    blob,
                    KeyPair::RSA {
                        key,
                        hash: SignatureHash::SHA2_256,
                    },
                )))
            }
            _ => Ok(None),
        }
    }
    fn write(&self, buf: &mut CryptoVec) -> Result<(), Self::Error> {
        match *self {
            KeyPair::Ed25519(ref secret) => {
                buf.extend_ssh_string(b"ssh-ed25519");
                let public = &secret.key[32..];
                buf.extend_ssh_string(public);
                buf.push_u32_be(64);
                buf.extend(&secret.key);
                buf.extend_ssh_string(b"");
            }
            #[cfg(feature = "openssl")]
            KeyPair::RSA { ref key, .. } => {
                buf.extend_ssh_string(b"ssh-rsa");
                buf.extend_ssh_mpint(&key.n().to_vec());
                buf.extend_ssh_mpint(&key.e().to_vec());
                buf.extend_ssh_mpint(&key.d().to_vec());
                if let Some(iqmp) = key.iqmp() {
                    buf.extend_ssh_mpint(&iqmp.to_vec());
                } else {
                    let mut ctx = openssl::bn::BigNumContext::new()?;
                    let mut iqmp = openssl::bn::BigNum::new()?;
                    iqmp.mod_inverse(key.p().unwrap(), key.q().unwrap(), &mut ctx)?;
                    buf.extend_ssh_mpint(&iqmp.to_vec());
                }
                buf.extend_ssh_mpint(&key.p().unwrap().to_vec());
                buf.extend_ssh_mpint(&key.q().unwrap().to_vec());
                buf.extend_ssh_string(b"");
            }
        }
        Ok(())
    }
    fn write_signature<Bytes: AsRef<[u8]>>(
        &self,
        buf: &mut CryptoVec,
        to_sign: Bytes,
    ) -> Result<(), Self::Error> {
        self.add_signature(buf, to_sign)
    }
}
impl agent_key::Public for PublicKey {
    type Error = Error;
    fn read(r: &mut Position) -> Result<Option<Self>, Self::Error> {
        let t = r.read_string()?;
        debug!("t = {:?}", std::str::from_utf8(t));
        match t {
            #[cfg(feature = "openssl")]
            b"ssh-rsa" => {
                let e = r.read_mpint()?;
                let n = r.read_mpint()?;
                use openssl::bn::BigNum;
                use openssl::pkey::PKey;
                use openssl::rsa::Rsa;
                Ok(Some(PublicKey::RSA {
                    key: OpenSSLPKey(PKey::from_rsa(Rsa::from_public_components(
                        BigNum::from_slice(n)?,
                        BigNum::from_slice(e)?,
                    )?)?),
                    hash: SignatureHash::SHA2_512,
                }))
            }
            b"ssh-ed25519" => {
                let mut p = ed25519::PublicKey::new_zeroed();
                p.key.clone_from_slice(r.read_string()?);
                Ok(Some(PublicKey::Ed25519(p)))
            }
            t => {
                info!("Unsupported key type: {:?}", std::str::from_utf8(t));
                Ok(None)
            }
        }
    }
    fn write_blob(&self, buf: &mut CryptoVec) {
        match *self {
            #[cfg(feature = "openssl")]
            PublicKey::RSA { ref key, .. } => {
                buf.extend(&[0, 0, 0, 0]);
                let len0 = buf.len();
                buf.extend_ssh_string(b"ssh-rsa");
                let rsa = key.0.rsa().unwrap();
                buf.extend_ssh_mpint(&rsa.e().to_vec());
                buf.extend_ssh_mpint(&rsa.n().to_vec());
                let len1 = buf.len();
                BigEndian::write_u32(&mut buf[5..], (len1 - len0) as u32);
            }
            PublicKey::Ed25519(ref p) => {
                buf.extend(&[0, 0, 0, 0]);
                let len0 = buf.len();
                buf.extend_ssh_string(b"ssh-ed25519");
                buf.extend_ssh_string(&p.key[0..]);
                let len1 = buf.len();
                BigEndian::write_u32(&mut buf[5..], (len1 - len0) as u32);
            }
        }
    }
    fn hash(&self) -> u32 {
        match self {
            #[cfg(feature = "openssl")]
            PublicKey::RSA { hash, .. } => match hash {
                SignatureHash::SHA2_256 => 2,
                SignatureHash::SHA2_512 => 4,
                SignatureHash::SHA1 => 0,
            },
            _ => 0,
        }
    }

Replacement in thrussh-keys/src/format/pkcs8.rs at line 102 [7.71340]
B:BD[7.75090] → [12.6323:6374]
∅:D[12.6374] → [7.75145:75183]
B:BD[7.75145] → [7.75145:75183]
B:BD[7.75203] → [7.75203:75215]
```
        Ok(digest.map(|()| KeyDerivation::Pbkdf2 {
            salt,
            rounds,
        }))
```
[7.75090]
[7.75215]
```
        Ok(digest.map(|()| KeyDerivation::Pbkdf2 { salt, rounds }))
```
Deletion in thrussh-keys/src/format/pkcs8.rs at line 261 [7.71340]
B:BD[7.80875] → [7.80875:80912]
```
use yasna::models::ObjectIdentifier;
```
Insertion in thrussh-keys/src/format/pkcs8.rs at line 264 [7.71340]
[12.6699]
[12.6699]
```
use yasna::models::ObjectIdentifier;
```

Replacement in thrussh-keys/src/format/pkcs8.rs at line 376 [7.71340]

B:BD[7.84334] → [7.84334:84420]

B:BD[7.84420] → [12.7244:7263]

            KeyDerivation::Pbkdf2 {
                ref salt,
                rounds,
            } => {

[7.84334]

[12.7263]

            KeyDerivation::Pbkdf2 { ref salt, rounds } => {

Replacement in thrussh-keys/src/format/pkcs8.rs at line 379 [7.71340]
B:BD[12.7436] → [12.7436:7451]
```
            },
```
[12.7436]
[7.84521]
```
            }
```
Replacement in thrussh-keys/src/format/pkcs8.rs at line 426 [7.71340]
B:BD[12.7760] → [12.7760:7775]
```
            },
```
[12.7760]
[12.7775]
```
            }
```
Replacement in thrussh-keys/src/format/pkcs8.rs at line 433 [7.71340]
B:BD[12.8043] → [12.8043:8058]
```
            },
```
[12.8043]
[12.8058]
```
            }
```
Replacement in thrussh-keys/src/format/pkcs8.rs at line 439 [7.71340]
B:BD[7.85644] → [7.85644:85701]
B:BD[7.85732] → [7.85732:85739]
```
    Pbkdf2 {
        salt: Vec<u8>,
        rounds: u64,
    },
```
[7.85644]
[7.85739]
```
    Pbkdf2 { salt: Vec<u8>, rounds: u64 },
```
Deletion in thrussh-keys/src/format/openssh.rs at line 1 [7.86809]
B:BD[7.86835] → [7.86835:86864]
```
use crate::encoding::Reader;
```
Insertion in thrussh-keys/src/format/openssh.rs at line 6 [7.86809]
[7.86981]
[7.87025]
```
use thrussh_encoding::Reader;
```
Insertion in thrussh-keys/Cargo.toml at line 48 [7.157024]
[7.158187]
[12.14033]
```
thrussh-agent = "0.1"
thrussh-encoding = "0.1"
```
File addition: thrussh-encoding (d--x------)
[1.0]
File addition: src (d--x------)
[0.9304]
File move: encoding.rs, encoding.rs → lib.rs
BF:BFD[7.5805] → [4.164:177]
BF:BFD[7.5805] → [14.164:177]
[0.9320]
[7.96067]
Deletion in thrussh-encoding/src/lib.rs at line 16 [7.96067]
B:BD[7.96668] → [7.96668:96686]
```
use crate::Error;
```
Insertion in thrussh-encoding/src/lib.rs at line 18 [7.96067]
[7.96766]
[7.96766]
```
use thiserror::Error;
```

Insertion in thrussh-encoding/src/lib.rs at line 20 [7.96067]

[7.96767]

#[derive(Debug, Error)]
pub enum Error {
    /// Index out of bounds
    #[error("Index out of bounds")]
    IndexOutOfBounds,
}

File addition: thrussh-agent (d--x------)
[1.0]
File addition: src (d--x------)
[0.9518]
File move: server.rs, server.rs → server.rs
BF:BFD[7.125224] → [4.218:229]
BF:BFD[7.125224] → [14.218:229]
[0.9534]
[7.125237]
Deletion in thrussh-agent/src/server.rs at line 1 [7.125237]
B:BD[7.125237] → [7.125238:125305]
B:BD[7.125305] → [12.13582:13610]
∅:D[12.13610] → [7.125305:125336]
B:BD[7.125305] → [7.125305:125336]
```
use crate::encoding::{Encoding, Position, Reader};
use crate::key;
#[cfg(feature = "openssl")]
use crate::key::SignatureHash;
```
Insertion in thrussh-agent/src/server.rs at line 10 [7.125237]
[7.125552]
[7.125552]
```
use thiserror::Error;
use thrussh_encoding::{Encoding, Position, Reader};
```

Replacement in thrussh-agent/src/server.rs at line 18 [7.125237]

B:BD[7.125740] → [7.125740:125758]

use crate::Error;

[7.125740]

[7.125758]

use crate::key::Private;
struct KeyStore<Key>(Arc<RwLock<HashMap<Vec<u8>, (Arc<Key>, SystemTime, Vec<Constraint>)>>>);

Replacement in thrussh-agent/src/server.rs at line 22 [7.125237]

B:BD[7.125759] → [7.125759:125874]

#[derive(Clone)]
struct KeyStore(Arc<RwLock<HashMap<Vec<u8>, (Arc<key::KeyPair>, SystemTime, Vec<Constraint>)>>>);

[7.125759]

[7.125874]

// NOTE: need to implement this since the derived version will require `Key: Clone` which is unecessary.
impl<Key> Clone for KeyStore<Key> {
    fn clone(&self) -> Self {
	KeyStore(self.0.clone())
    }
}

Insertion in thrussh-agent/src/server.rs at line 32 [7.125237]

[7.125930]

#[derive(Debug, Error)]
pub enum Error {
    #[error(transparent)]
    Encoding(#[from] thrussh_encoding::Error),
    #[error(transparent)]
    Private(Box<dyn std::error::Error + Send + Sync + 'static>),
    #[error(transparent)]
    Io(#[from] std::io::Error),
}

Replacement in thrussh-agent/src/server.rs at line 51 [7.125237]

B:BD[7.126027] → [7.126027:126196]

pub trait Agent: Clone + Send + 'static {
    fn confirm(
        self,
        _pk: Arc<key::KeyPair>,
    ) -> Box<dyn Future<Output = (Self, bool)> + Unpin + Send> {

[7.126027]

[7.126196]

pub trait Agent<Key>: Clone + Send + 'static {
    fn confirm(self, _pk: Arc<Key>) -> Box<dyn Future<Output = (Self, bool)> + Unpin + Send> {

Replacement in thrussh-agent/src/server.rs at line 57 [7.125237]

B:BD[7.126260] → [7.126260:126336]

pub async fn serve<S, L, A>(mut listener: L, agent: A) -> Result<(), Error>

[7.126260]

[7.126336]

pub async fn serve<K, S, L, A>(mut listener: L, agent: A) -> Result<(), Error>

Insertion in thrussh-agent/src/server.rs at line 59 [7.125237]

[7.126342]

    K: Private + Send + Sync + 'static,
K::Error: std::error::Error + Send + Sync + 'static,

Replacement in thrussh-agent/src/server.rs at line 63 [7.125237]
B:BD[7.126457] → [7.126457:126495]
```
    A: Agent + Send + Sync + 'static,
```
[7.126457]
[7.126495]
```
    A: Agent<K> + Send + Sync + 'static,
```

Replacement in thrussh-agent/src/server.rs at line 84 [7.125237]

B:BD[7.127039] → [7.127039:127184]

impl Agent for () {
    fn confirm(
        self,
        _: Arc<key::KeyPair>,
    ) -> Box<dyn Future<Output = (Self, bool)> + Unpin + Send> {

[7.127039]

[7.127184]

impl<K> Agent<K> for () {
    fn confirm(self, _: Arc<K>) -> Box<dyn Future<Output = (Self, bool)> + Unpin + Send> {

Replacement in thrussh-agent/src/server.rs at line 90 [7.125237]

B:BD[7.127248] → [7.127248:127322]

struct Connection<S: AsyncRead + AsyncWrite + Send + 'static, A: Agent> {

[7.127248]

[7.127322]

struct Connection<Key, S: AsyncRead + AsyncWrite + Send + 'static, A: Agent<Key>> {

Replacement in thrussh-agent/src/server.rs at line 92 [7.125237]
B:BD[7.127338] → [7.127338:127358]
```
    keys: KeyStore,
```
[7.127338]
[7.127358]
```
    keys: KeyStore<Key>,
```

Replacement in thrussh-agent/src/server.rs at line 98 [7.125237]

B:BD[7.127413] → [7.127413:127518]

impl<S: AsyncRead + AsyncWrite + Send + Unpin + 'static, A: Agent + Send + 'static>
    Connection<S, A>

[7.127413]

[7.127518]

impl<K, S, A> Connection<K, S, A>
where
    K: Private + Send + Sync + 'static,
K::Error: std::error::Error + Send + Sync + 'static,
    S: AsyncRead + AsyncWrite + Send + Unpin + 'static,
    A: Agent<K> + Send + 'static,

Replacement in thrussh-agent/src/server.rs at line 254 [7.125237]

∅:D[8.2788] → [7.132513:133343]

B:BD[7.132513] → [7.132513:133343]

B:BD[7.133343] → [12.13611:13651]

∅:D[12.13651] → [7.133343:135274]

B:BD[7.133343] → [7.133343:135274]

        let pos0 = r.position;
        let t = r.read_string()?;
        let (blob, key) = match t {
            b"ssh-ed25519" => {
                let public_ = r.read_string()?;
                let pos1 = r.position;
                let concat = r.read_string()?;
                let _comment = r.read_string()?;
                if &concat[32..64] != public_ {
                    return Ok(false);
                }
                use key::ed25519::*;
                let mut public = PublicKey::new_zeroed();
                let mut secret = SecretKey::new_zeroed();
                public.key.clone_from_slice(&public_[..32]);
                secret.key.clone_from_slice(&concat[..]);
                writebuf.push(msg::SUCCESS);
                (self.buf[pos0..pos1].to_vec(), key::KeyPair::Ed25519(secret))
            }
            #[cfg(feature = "openssl")]
            b"ssh-rsa" => {
                use openssl::bn::{BigNum, BigNumContext};
                use openssl::rsa::Rsa;
                let n = r.read_mpint()?;
                let e = r.read_mpint()?;
                let d = BigNum::from_slice(r.read_mpint()?)?;
                let q_inv = r.read_mpint()?;
                let p = BigNum::from_slice(r.read_mpint()?)?;
                let q = BigNum::from_slice(r.read_mpint()?)?;
                let (dp, dq) = {
                    let one = BigNum::from_u32(1)?;
                    let p1 = p.as_ref() - one.as_ref();
                    let q1 = q.as_ref() - one.as_ref();
                    let mut context = BigNumContext::new()?;
                    let mut dp = BigNum::new()?;
                    let mut dq = BigNum::new()?;
                    dp.checked_rem(&d, &p1, &mut context)?;
                    dq.checked_rem(&d, &q1, &mut context)?;
                    (dp, dq)
                };
                let _comment = r.read_string()?;
                let key = Rsa::from_private_components(
                    BigNum::from_slice(n)?,
                    BigNum::from_slice(e)?,
                    d,
                    p,
                    q,
                    dp,
                    dq,
                    BigNum::from_slice(&q_inv)?,
                )?;
                let len0 = writebuf.len();
                writebuf.extend_ssh_string(b"ssh-rsa");
                writebuf.extend_ssh_mpint(&e);
                writebuf.extend_ssh_mpint(&n);
                let blob = writebuf[len0..].to_vec();
                writebuf.resize(len0);
                writebuf.push(msg::SUCCESS);
                (
                    blob,
                    key::KeyPair::RSA {
                        key,
                        hash: SignatureHash::SHA2_256,
                    },
                )
            }
            _ => return Ok(false),

[8.2788]

[7.135274]

        let (blob, key) = match K::read(&mut r).map_err(|err| Error::Private(Box::new(err)))? {
	    Some((blob, key)) => (blob, key),
            None => return Ok(false),

Insertion in thrussh-agent/src/server.rs at line 258 [7.125237]
[7.135285]
[7.135285]
```
	writebuf.push(msg::SUCCESS);
```

Replacement in thrussh-agent/src/server.rs at line 326 [7.125237]

B:BD[7.137674] → [7.137674:137718]

        key.add_signature(writebuf, data)?;

[7.137674]

[7.137718]

        key.write_signature(writebuf, data).map_err(|err| Error::Private(Box::new(err)))?;

File move: msg.rs, msg.rs → msg.rs
BF:BFD[7.125224] → [4.230:238]
BF:BFD[7.125224] → [14.230:238]
[0.9534]
[7.137855]
File move: mod.rs, mod.rs → lib.rs
BF:BFD[7.125224] → [4.239:247]
BF:BFD[7.125224] → [14.239:247]
[0.9534]
[7.138582]
Insertion in thrussh-agent/src/lib.rs at line 1 [7.138582]
[7.138582]
[7.138583]
```
#[macro_use]
extern crate log;
```
Insertion in thrussh-agent/src/lib.rs at line 6 [7.138582]
[7.138633]
[7.138633]
```
pub mod key;
```
File move: client.rs, client.rs → client.rs
BF:BFD[7.125224] → [4.248:259]
BF:BFD[7.125224] → [14.248:259]
[0.9534]
[7.139093]
Replacement in thrussh-agent/src/client.rs at line 3 [7.139093]
B:BD[7.139133] → [7.139133:139174]
B:BD[7.139174] → [7.139174:139234]
B:BD[7.139234] → [7.139234:139252]
```
use crate::encoding::{Encoding, Reader};
use crate::key;
use crate::key::{PublicKey, SignatureHash};
use crate::Error;
```
[7.139133]
[7.139252]
```
use crate::key::{Private, Public, Signature};
```
Insertion in thrussh-agent/src/client.rs at line 6 [7.139093]
[7.139317]
[7.139317]
```
use std::fmt;
use thiserror::Error;
use thrussh_encoding::{Encoding, Reader};
```

Insertion in thrussh-agent/src/client.rs at line 11 [7.139093]

[7.139397]


#[derive(Debug, Error)]
pub enum Error {
    /// Agent protocol error
    #[error("Agent protocol error")]
    AgentProtocolError,
    #[error("Agent failure")]
    AgentFailure,
    #[error(
        "Unable to connect to ssh-agent. The environment variable `SSH_AUTH_SOCK` \
    was set, but it points to a nonexistent file or directory."
    )]
    BadAuthSock,
    #[error(transparent)]
    Encoding(#[from] thrussh_encoding::Error),
    #[error("Environment variable `{0}` not found")]
    EnvVar(&'static str),
    #[error(transparent)]
    Io(#[from] std::io::Error),
    #[error(transparent)]
    Private(Box<dyn std::error::Error + Send + Sync + 'static>),

Insertion in thrussh-agent/src/client.rs at line 39 [7.139093]

[7.139398]

    #[error(transparent)]
    Public(Box<dyn std::error::Error + Send + Sync + 'static>),
    #[error(transparent)]
    Signature(Box<dyn std::error::Error + Send + Sync + 'static>),
}

Replacement in thrussh-agent/src/client.rs at line 85 [7.139093]

B:BD[11.217] → [11.217:356]

            Err(Error::IO(io_err)) if io_err.kind() == std::io::ErrorKind::NotFound => Err(Error::BadAuthSock),
            owise => owise

[11.217]

[11.356]

            Err(Error::Io(io_err)) if io_err.kind() == std::io::ErrorKind::NotFound => {
                Err(Error::BadAuthSock)
            }
            owise => owise,

Replacement in thrussh-agent/src/client.rs at line 124 [7.139093]
B:BD[7.141356] → [7.141356:141387]
```
    pub async fn add_identity(
```
[7.141356]
[7.141387]
```
    pub async fn add_identity<K>(
```
Replacement in thrussh-agent/src/client.rs at line 126 [7.139093]
B:BD[7.141406] → [7.141406:141434]
```
        key: &key::KeyPair,
```
[7.141406]
[7.141434]
```
        key: &K,
```

Replacement in thrussh-agent/src/client.rs at line 128 [7.139093]

B:BD[7.141470] → [8.3294:3323]

    ) -> Result<(), Error> {

[7.141470]

[7.141507]

    ) -> Result<(), Error>
    where
        K: Private,
        K::Error: std::error::Error + Send + Sync + 'static,
    {

Replacement in thrussh-agent/src/client.rs at line 140 [7.139093]

B:BD[7.141720] → [7.141720:142103]

B:BD[7.142103] → [12.13652:13692]

∅:D[12.13692] → [7.142103:143048]

B:BD[7.142103] → [7.142103:143048]

        match *key {
            key::KeyPair::Ed25519(ref secret) => {
                self.buf.extend_ssh_string(b"ssh-ed25519");
                let public = &secret.key[32..];
                self.buf.extend_ssh_string(public);
                self.buf.push_u32_be(64);
                self.buf.extend(&secret.key);
                self.buf.extend_ssh_string(b"");
            }
            #[cfg(feature = "openssl")]
            key::KeyPair::RSA { ref key, .. } => {
                self.buf.extend_ssh_string(b"ssh-rsa");
                self.buf.extend_ssh_mpint(&key.n().to_vec());
                self.buf.extend_ssh_mpint(&key.e().to_vec());
                self.buf.extend_ssh_mpint(&key.d().to_vec());
                if let Some(iqmp) = key.iqmp() {
                    self.buf.extend_ssh_mpint(&iqmp.to_vec());
                } else {
                    let mut ctx = openssl::bn::BigNumContext::new()?;
                    let mut iqmp = openssl::bn::BigNum::new()?;
                    iqmp.mod_inverse(key.p().unwrap(), key.q().unwrap(), &mut ctx)?;
                    self.buf.extend_ssh_mpint(&iqmp.to_vec());
                }
                self.buf.extend_ssh_mpint(&key.p().unwrap().to_vec());
                self.buf.extend_ssh_mpint(&key.q().unwrap().to_vec());
                self.buf.extend_ssh_string(b"");
            }
        }

[7.141720]

[7.143048]

        key.write(&mut self.buf)
            .map_err(|err| Error::Private(Box::new(err)))?;

Replacement in thrussh-agent/src/client.rs at line 238 [7.139093]

B:BD[7.146604] → [8.3508:3590]

    pub async fn request_identities(&mut self) -> Result<Vec<PublicKey>, Error> {

[7.146604]

[7.146694]

    pub async fn request_identities<K>(&mut self) -> Result<Vec<K>, Error>
    where
        K: Public,
        K::Error: std::error::Error + Send + Sync + 'static,
    {

Replacement in thrussh-agent/src/client.rs at line 259 [7.139093]

B:BD[7.147307] → [7.147307:147435]

B:BD[7.147435] → [12.13693:13741]

∅:D[12.13741] → [7.147435:148374]

B:BD[7.147435] → [7.147435:148374]

B:BD[7.148374] → [3.0:133]

                let t = r.read_string()?;
                debug!("t = {:?}", std::str::from_utf8(t));
                match t {
                    #[cfg(feature = "openssl")]
                    b"ssh-rsa" => {
                        let e = r.read_mpint()?;
                        let n = r.read_mpint()?;
                        use openssl::bn::BigNum;
                        use openssl::pkey::PKey;
                        use openssl::rsa::Rsa;
                        keys.push(PublicKey::RSA {
                            key: key::OpenSSLPKey(PKey::from_rsa(Rsa::from_public_components(
                                BigNum::from_slice(n)?,
                                BigNum::from_slice(e)?,
                            )?)?),
                            hash: SignatureHash::SHA2_512,
                        })
                    }
                    b"ssh-ed25519" => {
                        let mut p = key::ed25519::PublicKey::new_zeroed();
                        p.key.clone_from_slice(r.read_string()?);
                        keys.push(PublicKey::Ed25519(p))
                    }
                    t => {
                        info!("Unsupported key type: {:?}", std::str::from_utf8(t))
                    }

[7.147307]

[7.148457]

                if let Some(pk) = K::read(&mut r).map_err(|err| Error::Public(Box::new(err)))? {
                    keys.push(pk);

Replacement in thrussh-agent/src/client.rs at line 269 [7.139093]
B:BD[7.148582] → [7.148582:148607]
```
    pub fn sign_request(
```
[7.148582]
[7.148607]
```
    pub fn sign_request<K>(
```
Replacement in thrussh-agent/src/client.rs at line 271 [7.139093]
B:BD[7.148625] → [7.148625:148658]
```
        public: &key::PublicKey,
```
[7.148625]
[7.148658]
```
        public: &K,
```

Replacement in thrussh-agent/src/client.rs at line 273 [7.139093]

B:BD[7.148687] → [8.3591:3666]

    ) -> impl futures::Future<Output = (Self, Result<CryptoVec, Error>)> {

[7.148687]

[7.148770]

    ) -> impl futures::Future<Output = (Self, Result<CryptoVec, Error>)>
    where
        K: Public + fmt::Debug,
    {

Replacement in thrussh-agent/src/client.rs at line 301 [7.139093]

B:BD[7.149611] → [7.149611:149697]

    fn prepare_sign_request(&mut self, public: &key::PublicKey, data: &[u8]) -> u32 {

[7.149611]

[7.149697]

    fn prepare_sign_request<K>(&mut self, public: &K, data: &[u8]) -> u32
    where
        K: Public + fmt::Debug,
    {

Replacement in thrussh-agent/src/client.rs at line 308 [7.139093]
B:BD[7.149793] → [7.149793:149835]
```
        key_blob(&public, &mut self.buf);
```
[7.149793]
[7.149835]
```
        public.write_blob(&mut self.buf);
```

Replacement in thrussh-agent/src/client.rs at line 311 [7.139093]

B:BD[7.149918] → [7.149918:149952]

B:BD[7.149952] → [12.13742:13782]

∅:D[12.13782] → [7.149952:150188]

B:BD[7.149952] → [7.149952:150188]

        let hash = match public {
            #[cfg(feature = "openssl")]
            PublicKey::RSA { hash, .. } => match hash {
                SignatureHash::SHA2_256 => 2,
                SignatureHash::SHA2_512 => 4,
                SignatureHash::SHA1 => 0,
            },
            _ => 0,
        };

[7.149918]

[7.150188]

        let hash = public.hash();

Replacement in thrussh-agent/src/client.rs at line 332 [7.139093]
B:BD[7.150944] → [7.150944:150976]
```
    pub fn sign_request_base64(
```
[7.150944]
[7.150976]
```
    pub fn sign_request_base64<K>(
```
Replacement in thrussh-agent/src/client.rs at line 334 [7.139093]
B:BD[7.150994] → [7.150994:151027]
```
        public: &key::PublicKey,
```
[7.150994]
[7.151027]
```
        public: &K,
```

Replacement in thrussh-agent/src/client.rs at line 336 [7.139093]

B:BD[7.151048] → [8.3754:3826]

    ) -> impl futures::Future<Output = (Self, Result<String, Error>)> {

[7.151048]

[7.151128]

    ) -> impl futures::Future<Output = (Self, Result<String, Error>)>
    where
        K: Public + fmt::Debug,
    {

Replacement in thrussh-agent/src/client.rs at line 358 [7.139093]
B:BD[7.151752] → [7.151752:151787]
```
    pub fn sign_request_signature(
```
[7.151752]
[7.151787]
```
    pub fn sign_request_signature<K, Sig>(
```
Replacement in thrussh-agent/src/client.rs at line 360 [7.139093]
B:BD[7.151805] → [7.151805:151838]
```
        public: &key::PublicKey,
```
[7.151805]
[7.151838]
```
        public: &K,
```

Replacement in thrussh-agent/src/client.rs at line 362 [7.139093]

B:BD[7.151859] → [4.260:353]

    ) -> impl futures::Future<Output = (Self, Result<crate::signature::Signature, Error>)> {

[7.151859]

[7.151964]

    ) -> impl futures::Future<Output = (Self, Result<Sig, Error>)>
    where
        K: Public + fmt::Debug,
        Sig: Signature,
        Sig::Error: std::error::Error + Send + Sync +
	'static,
    {

Replacement in thrussh-agent/src/client.rs at line 377 [7.139093]

B:BD[7.152195] → [4.465:607]

∅:D[4.607] → [7.152327:153559]

B:BD[7.152327] → [7.152327:153559]

B:BD[7.153559] → [7.153559:153578]

B:BD[7.153578] → [4.608:653]

                let as_sig = |buf: &CryptoVec| -> Result<crate::signature::Signature, Error> {
                    let mut r = buf.reader(1);
                    let mut resp = r.read_string()?.reader(0);
                    let typ = resp.read_string()?;
                    let sig = resp.read_string()?;
                    use crate::signature::Signature;
                    match typ {
                        b"rsa-sha2-256" => Ok(Signature::RSA {
                            bytes: sig.to_vec(),
                            hash: SignatureHash::SHA2_256,
                        }),
                        b"rsa-sha2-512" => Ok(Signature::RSA {
                            bytes: sig.to_vec(),
                            hash: SignatureHash::SHA2_512,
                        }),
                        b"ssh-ed25519" => {
                            let mut sig_bytes = [0; 64];
                            sig_bytes.clone_from_slice(sig);
                            Ok(Signature::Ed25519(crate::signature::SignatureBytes(
                                sig_bytes,
                            )))
                        }
                        _ => Err((Error::UnknownSignatureType {
                            sig_type: std::str::from_utf8(typ).unwrap_or("").to_string(),
                        })
                        .into()),
                    }
                };
                let sig = as_sig(&self.buf);

[7.152195]

[4.653]

                let sig = Sig::read(&self.buf).map_err(|err| Error::Signature(Box::new(err)));

Replacement in thrussh-agent/src/client.rs at line 386 [7.139093]

B:BD[7.153772] → [8.3994:4086]

    pub async fn remove_identity(&mut self, public: &key::PublicKey) -> Result<(), Error> {

[7.153772]

[7.153872]

    pub async fn remove_identity<K>(&mut self, public: &K) -> Result<(), Error>
    where
        K: Public,
    {

Replacement in thrussh-agent/src/client.rs at line 393 [7.139093]
B:BD[7.153971] → [7.153971:154012]
```
        key_blob(public, &mut self.buf);
```
[7.153971]
[7.154012]
```
        public.write_blob(&mut self.buf);
```

Deletion in thrussh-agent/src/client.rs at line 450 [7.139093]

B:BD[7.156158] → [7.156158:156166]

B:BD[7.156166] → [7.156166:156247]

B:BD[7.156247] → [12.13783:13819]

∅:D[12.13819] → [7.156247:157002]

B:BD[7.156247] → [7.156247:157002]

    }
}
fn key_blob(public: &key::PublicKey, buf: &mut CryptoVec) {
    match *public {
        #[cfg(feature = "openssl")]
        PublicKey::RSA { ref key, .. } => {
            buf.extend(&[0, 0, 0, 0]);
            let len0 = buf.len();
            buf.extend_ssh_string(b"ssh-rsa");
            let rsa = key.0.rsa().unwrap();
            buf.extend_ssh_mpint(&rsa.e().to_vec());
            buf.extend_ssh_mpint(&rsa.n().to_vec());
            let len1 = buf.len();
            BigEndian::write_u32(&mut buf[5..], (len1 - len0) as u32);
        }
        PublicKey::Ed25519(ref p) => {
            buf.extend(&[0, 0, 0, 0]);
            let len0 = buf.len();
            buf.extend_ssh_string(b"ssh-ed25519");
            buf.extend_ssh_string(&p.key[0..]);
            let len1 = buf.len();
            BigEndian::write_u32(&mut buf[5..], (len1 - len0) as u32);
        }

Replacement in thrussh/src/session.rs at line 24 [7.171602]
B:BD[7.172498] → [7.172498:172536]
```
use thrussh_keys::encoding::Encoding;
```
[7.172498]
[7.172536]
```
use thrussh_encoding::Encoding;
```
Replacement in thrussh/src/server/session.rs at line 4 [7.188192]
B:BD[7.188243] → [7.188243:188281]
```
use thrussh_keys::encoding::Encoding;
```
[7.188243]
[7.188281]
```
use thrussh_encoding::Encoding;
```
Replacement in thrussh/src/server/mod.rs at line 90 [7.203388]
B:BD[7.206416] → [7.206416:206463]
```
    pos: thrussh_keys::encoding::Position<'a>,
```
[7.206416]
[7.206463]
```
    pos: thrussh_encoding::Position<'a>,
```
Replacement in thrussh/src/server/kex.rs at line 7 [7.225726]
B:BD[7.225888] → [7.225888:225936]
```
use thrussh_keys::encoding::{Encoding, Reader};
```
[7.225888]
[7.225936]
```
use thrussh_encoding::{Encoding, Reader};
```
Replacement in thrussh/src/server/encrypted.rs at line 23 [7.230083]
B:BD[7.230845] → [7.230845:230903]
```
use thrussh_keys::encoding::{Encoding, Position, Reader};
```
[7.230845]
[7.230903]
```
use thrussh_encoding::{Encoding, Position, Reader};
```

Replacement in thrussh/src/server/encrypted.rs at line 103 [7.230083]

B:BD[6.220] → [6.220:274]

                    return Err(Error::Pending.into())

[6.220]

[6.274]

                    return Err(Error::Pending.into());

Replacement in thrussh/src/server/encrypted.rs at line 111 [7.230083]
B:BD[15.652] → [15.652:667]
```
            },
```
[15.652]
[7.233300]
```
            }
```
Deletion in thrussh/src/negotiation.rs at line 21 [7.268386]
B:BD[7.269180] → [7.269180:269228]
B:BD[7.269228] → [7.269228:269273]
```
use thrussh_keys::encoding::{Encoding, Reader};
use thrussh_keys::key::{KeyPair, PublicKey};
```

Insertion in thrussh/src/negotiation.rs at line 22 [7.268386]

[16.512]

[7.269273]

use thrussh_encoding::{Encoding, Reader};
use thrussh_keys::key::{KeyPair, PublicKey};

Insertion in thrussh/src/negotiation.rs at line 97 [7.268386]
[7.270951]
[16.513]
```
#[cfg(not(feature = "openssl"))]
use thrussh_keys::key::ED25519;
```
Deletion in thrussh/src/negotiation.rs at line 101 [7.268386]
B:BD[7.270994] → [16.542:609]
```
#[cfg(not(feature = "openssl"))]
use thrussh_keys::key::{ED25519};
```

Replacement in thrussh/src/lib.rs at line 201 [7.278640]

B:BD[7.286255] → [7.286255:286349]

//!   let mut agent = thrussh_keys::agent::client::AgentClient::connect_env().await.unwrap();

[7.286255]

[7.286349]

//!   let mut agent = thrussh_agent::client::AgentClient::connect_env().await.unwrap();

Replacement in thrussh/src/lib.rs at line 309 [7.278640]

B:BD[16.742] → [16.742:849]

type Sha256Hash = generic_array::GenericArray<u8, <sha2::Sha256 as digest::FixedOutputDirty>::OutputSize>;

[16.742]

[16.849]

type Sha256Hash =
    generic_array::GenericArray<u8, <sha2::Sha256 as digest::FixedOutputDirty>::OutputSize>;

Insertion in thrussh/src/lib.rs at line 415 [7.278640]

[8.13173]


    #[error(transparent)]
    Encoding(#[from] thrussh_encoding::Error),

Replacement in thrussh/src/key.rs at line 16 [7.304500]
B:BD[7.305126] → [7.305126:305157]
```
use thrussh_keys::encoding::*;
```
[7.305126]
[7.305157]
```
use thrussh_encoding::*;
```
Insertion in thrussh/src/kex.rs at line 20 [7.306916]
[7.307643]
[7.307656]
```
use rand::RngCore;
```
Replacement in thrussh/src/kex.rs at line 23 [7.306916]
B:BD[7.307692] → [7.307692:307730]
B:BD[7.307730] → [16.995:1014]
```
use thrussh_keys::encoding::Encoding;
use rand::RngCore;
```
[7.307692]
[7.307730]
```
use thrussh_encoding::Encoding;
```

Replacement in thrussh/src/kex.rs at line 180 [7.306916]

B:BD[7.313028] → [16.1411:1463]

                    let hash =                    {

[7.313028]

[16.1463]

                    let hash = {

Replacement in thrussh/src/client/mod.rs at line 30 [7.334998]
B:BD[7.335997] → [7.335997:336045]
```
use thrussh_keys::encoding::{Encoding, Reader};
```
[7.335997]
[7.336045]
```
use thrussh_encoding::{Encoding, Reader};
```
Deletion in thrussh/src/client/mod.rs at line 213 [7.334998]
B:BD[8.15617] → [5.0:1]
Replacement in thrussh/src/client/encrypted.rs at line 26 [7.383877]
B:BD[7.384775] → [7.384775:384823]
```
use thrussh_keys::encoding::{Encoding, Reader};
```
[7.384775]
[7.384823]
```
use thrussh_encoding::{Encoding, Reader};
```

Replacement in thrussh/src/client/encrypted.rs at line 117 [7.383877]

B:BD[6.574] → [6.574:632]

                        return Err(Error::Pending.into())

[6.574]

[6.632]

                        return Err(Error::Pending.into());

Replacement in thrussh/src/auth.rs at line 18 [7.421956]
B:BD[7.422603] → [7.422603:422631]
```
use thrussh_keys::encoding;
```
[7.422603]
[7.422631]
```
use thrussh_encoding as encoding;
```
Insertion in thrussh/src/auth.rs at line 74 [7.421956]
[8.23555]
[8.23555]
Replacement in thrussh/src/auth.rs at line 76 [7.421956]
B:BD[8.23581] → [8.23581:23619]
```
    Key(#[from] thrussh_keys::Error),
```
[8.23581]
[7.424209]
```
    Client(#[from] thrussh_agent::client::Error),
```
Replacement in thrussh/src/auth.rs at line 80 [7.421956]
B:BD[7.424276] → [7.424276:424328]
```
    for thrussh_keys::agent::client::AgentClient<R>
```
[7.424276]
[7.424328]
```
    for thrussh_agent::client::AgentClient<R>
```

Replacement in thrussh/src/auth.rs at line 90 [7.421956]

B:BD[8.23960] → [8.23960:24008]

            (a, b.map_err(AgentAuthError::Key))

[8.23960]

[8.24008]

            (a, b.map_err(AgentAuthError::Client))

Replacement in thrussh/examples/remote_shell_call.rs at line 53 [17.23]

B:BD[17.1569] → [17.1569:1643]

        let mut agent = agent::client::AgentClient::connect_env().await?;

[17.1569]

[17.1643]

        let mut agent = thrussh_agent::client::AgentClient::connect_env().await?;

Replacement in thrussh/examples/client.rs at line 37 [18.24]

B:BD[18.1051] → [18.1051:1127]

    let mut agent = thrussh_keys::agent::client::AgentClient::connect_env()

[18.1051]

[18.1127]

    let mut agent = thrussh_agent::client::AgentClient::connect_env()

Insertion in thrussh/Cargo.toml at line 50 [7.426118]
[16.1925]
[7.427122]
```
thrussh-agent = "0.1"
thrussh-encoding = "0.1"
```
Insertion in cryptovec/src/lib.rs at line 403 [7.427990]
[7.439904]
[7.439904]
```
    /// use cryptovec::CryptoVec;
    ///
```

Replacement in Cargo.toml at line 3 [7.453741]

B:BD[7.453755] → [7.453755:453847]

members = [ "thrussh-keys", "thrussh", "thrussh-libsodium", "thrussh-config", "cryptovec" ]

[7.453755]

[7.453847]

members = [ "thrussh-agent", "thrussh-encoding", "thrussh-keys", "thrussh", "thrussh-libsodium", "thrussh-config", "cryptovec" ]

Insertion in Cargo.toml at line 7 [7.453741]

[7.453897]

thrussh-agent = { path = "thrussh-agent" }
thrussh-encoding = { path = "thrussh-encoding" }

Replacement in Cargo.toml at line 12 [7.453741]
B:BD[7.454024] → [7.454024:454068]
```
thrussh-config = { path = "thrussh-config" }
```
[7.454024]
```
thrussh-config = { path = "thrussh-config" }
```

Dependencies

In discussions

Change contents

Replacement in thrussh-keys/src/signature.rs at line 23 [7.5821]

Replacement in thrussh-keys/src/signature.rs at line 55 [7.5821]

Deletion in thrussh-keys/src/lib.rs at line 73 [7.21590]

Deletion in thrussh-keys/src/lib.rs at line 79 [7.21590]

Insertion in thrussh-keys/src/lib.rs at line 81 [7.21590]

Replacement in thrussh-keys/src/lib.rs at line 101 [7.21590]

Replacement in thrussh-keys/src/lib.rs at line 106 [7.21590]

Deletion in thrussh-keys/src/lib.rs at line 121 [7.21590]

Replacement in thrussh-keys/src/lib.rs at line 187 [7.21590]

Replacement in thrussh-keys/src/lib.rs at line 213 [7.21590]

Replacement in thrussh-keys/src/lib.rs at line 759 [7.21590]

Replacement in thrussh-keys/src/lib.rs at line 761 [7.21590]

Replacement in thrussh-keys/src/lib.rs at line 809 [7.21590]

Replacement in thrussh-keys/src/lib.rs at line 813 [7.21590]

Replacement in thrussh-keys/src/lib.rs at line 841 [7.21590]

Deletion in thrussh-keys/src/key.rs at line 15 [7.57451]

Insertion in thrussh-keys/src/key.rs at line 17 [7.57451]

Insertion in thrussh-keys/src/key.rs at line 21 [7.57451]

Replacement in thrussh-keys/src/key.rs at line 159 [7.57451]

Replacement in thrussh-keys/src/key.rs at line 227 [7.57451]

Deletion in thrussh-keys/src/key.rs at line 233 [7.57451]

Replacement in thrussh-keys/src/key.rs at line 247 [7.57451]

Replacement in thrussh-keys/src/key.rs at line 283 [7.57451]

Replacement in thrussh-keys/src/key.rs at line 306 [7.57451]

Insertion in thrussh-keys/src/key.rs at line 464 [7.57451]

Replacement in thrussh-keys/src/format/pkcs8.rs at line 102 [7.71340]

Deletion in thrussh-keys/src/format/pkcs8.rs at line 261 [7.71340]

Insertion in thrussh-keys/src/format/pkcs8.rs at line 264 [7.71340]

Replacement in thrussh-keys/src/format/pkcs8.rs at line 376 [7.71340]

Replacement in thrussh-keys/src/format/pkcs8.rs at line 379 [7.71340]

Replacement in thrussh-keys/src/format/pkcs8.rs at line 426 [7.71340]

Replacement in thrussh-keys/src/format/pkcs8.rs at line 433 [7.71340]

Replacement in thrussh-keys/src/format/pkcs8.rs at line 439 [7.71340]

Deletion in thrussh-keys/src/format/openssh.rs at line 1 [7.86809]

Insertion in thrussh-keys/src/format/openssh.rs at line 6 [7.86809]

Insertion in thrussh-keys/Cargo.toml at line 48 [7.157024]

File addition: thrussh-encoding (d--x------)

File addition: src (d--x------)

File move: encoding.rs, encoding.rs → lib.rs

Deletion in thrussh-encoding/src/lib.rs at line 16 [7.96067]

Insertion in thrussh-encoding/src/lib.rs at line 18 [7.96067]

Insertion in thrussh-encoding/src/lib.rs at line 20 [7.96067]

File addition: thrussh-agent (d--x------)

File addition: src (d--x------)

File move: server.rs, server.rs → server.rs

Deletion in thrussh-agent/src/server.rs at line 1 [7.125237]

Insertion in thrussh-agent/src/server.rs at line 10 [7.125237]

Replacement in thrussh-agent/src/server.rs at line 18 [7.125237]

Replacement in thrussh-agent/src/server.rs at line 22 [7.125237]

Insertion in thrussh-agent/src/server.rs at line 32 [7.125237]

Replacement in thrussh-agent/src/server.rs at line 51 [7.125237]

Replacement in thrussh-agent/src/server.rs at line 57 [7.125237]

Insertion in thrussh-agent/src/server.rs at line 59 [7.125237]

Replacement in thrussh-agent/src/server.rs at line 63 [7.125237]

Replacement in thrussh-agent/src/server.rs at line 84 [7.125237]

Replacement in thrussh-agent/src/server.rs at line 90 [7.125237]

Replacement in thrussh-agent/src/server.rs at line 92 [7.125237]

Replacement in thrussh-agent/src/server.rs at line 98 [7.125237]

Replacement in thrussh-agent/src/server.rs at line 254 [7.125237]

Insertion in thrussh-agent/src/server.rs at line 258 [7.125237]

Replacement in thrussh-agent/src/server.rs at line 326 [7.125237]

File move: msg.rs, msg.rs → msg.rs

File move: mod.rs, mod.rs → lib.rs

Insertion in thrussh-agent/src/lib.rs at line 1 [7.138582]

Insertion in thrussh-agent/src/lib.rs at line 6 [7.138582]

File move: client.rs, client.rs → client.rs

Replacement in thrussh-agent/src/client.rs at line 3 [7.139093]

Insertion in thrussh-agent/src/client.rs at line 6 [7.139093]