ilyagr/pijul - Change LZOGKBJXRQJKXHYNNENJFGNLP5SHIXGSV6HDB7UVOP7FSA5EUNCQC

new command `pijul client` for authenticating to a HTTP server

Created by pmeunier on April 23, 2023

LZOGKBJXRQJKXHYNNENJFGNLP5SHIXGSV6HDB7UVOP7FSA5EUNCQC

Dependencies

In channels

main

Change contents

Replacement in pijul/src/remote/ssh.rs at line 249 [9.25380]

B:BD[6.1493] → [6.1493:1701]

                        .with_prompt(format!("Password for encrypted private key"))
                        .allow_empty_password(false)
                        .interact()
                        .unwrap();

[6.1493]

[6.1701]

                    .with_prompt(format!("Password for encrypted private key"))
                    .allow_empty_password(false)
                    .interact()
                    .unwrap();

Replacement in pijul/src/remote/ssh.rs at line 256 [9.25380]

B:BD[6.1851] → [6.1851:1884]

                        continue

[6.1851]

[6.1884]

                        continue;

Insertion in pijul/src/remote/mod.rs at line 1121 [9.52474]

[9.68736]

[10.4650]

    pub async fn prove(&mut self, key: libpijul::key::SKey) -> Result<(), anyhow::Error> {
        match *self {
            RemoteRepo::Ssh(ref mut s) => s.prove(key).await,
            RemoteRepo::Http(ref mut h) => h.prove(key).await,
            RemoteRepo::None => unreachable!(),
            _ => Ok(()),
        }
    }

Replacement in pijul/src/remote/http.rs at line 41 [13.10]
∅:D[11.24470] → [12.259:314]
B:BD[12.259] → [12.259:314]
```
    std::fs::create_dir_all(&path.parent().unwrap())?;
```
[11.24470]
[12.314]
```
    tokio::fs::create_dir_all(&path.parent().unwrap()).await.unwrap();
```

Replacement in pijul/src/remote/http.rs at line 43 [13.10]

B:BD[12.358] → [14.33:89]

    let mut f = tokio::fs::File::create(&path_).await?;

[12.358]

[12.499]

    let mut f = tokio::fs::File::create(&path_).await.unwrap();

Insertion in pijul/src/remote/http.rs at line 75 [13.10]
[15.2168]
[15.2168]
```
            debug!("kv = {:?} {:?}", k, v);
```

Replacement in pijul/src/remote/http.rs at line 92 [13.10]

B:BD[14.849] → [14.849:896]

            delay *= 2.;
            continue;

[14.849]

[12.1183]

            bail!("Server returned {}", res.status().as_u16())

Replacement in pijul/src/remote/http.rs at line 126 [13.10]

B:BD[14.1304] → [7.831:874]

    debug!("renaming {:?} {:?}", c, done);

[14.1304]

    debug!("renaming {:?} {:?} {:?} {:?}", c, path_, path, done);

Replacement in pijul/src/remote/http.rs at line 130 [13.10]

B:BD[11.24556] → [11.24556:24605]

                std::fs::rename(&path_, &path)?;

[11.24556]

[11.24605]

                tokio::fs::rename(&path_, &path).await?;

Replacement in pijul/src/remote/http.rs at line 133 [13.10]

B:BD[11.24649] → [11.24649:24698]

                std::fs::rename(&path_, &path)?;

[11.24649]

[11.24698]

                tokio::fs::rename(&path_, &path).await?;

Replacement in pijul/src/remote/http.rs at line 141 [13.10]
B:BD[12.1406] → [12.1406:1435]
```
const POOL_SIZE: usize = 20;
```
[12.1406]
[13.209]
```
const POOL_SIZE: usize = 1;
```
Insertion in pijul/src/remote/http.rs at line 272 [13.10]
[15.2480]
[15.2480]
```
                debug!("kv = {:?} {:?}", k, v);
```
Insertion in pijul/src/remote/http.rs at line 325 [13.10]
[15.2740]
[15.2740]
```
            debug!("kv = {:?} {:?}", k, v);
```
Insertion in pijul/src/remote/http.rs at line 343 [13.10]
[16.5994]
[16.5994]
```
                debug!("l = {:?}", l);
```
Insertion in pijul/src/remote/http.rs at line 359 [13.10]
[16.6474]
[16.6474]
```
            debug!("done");
```
Insertion in pijul/src/remote/http.rs at line 384 [13.10]
[15.2976]
[15.2976]
```
            debug!("kv = {:?} {:?}", k, v);
```
Insertion in pijul/src/remote/http.rs at line 418 [13.10]
[15.3212]
[15.3212]
```
            debug!("kv = {:?} {:?}", k, v);
```

Replacement in pijul/src/remote/http.rs at line 504 [13.10]

B:BD[17.11753] → [17.11753:11792]

                    format!("{}", rev)

[17.11753]

[17.11792]

                    rev.to_string()

Replacement in pijul/src/remote/http.rs at line 506 [13.10]
B:BD[17.11817] → [17.11817:11851]
```
                    String::new()
```
[17.11817]
[17.11851]
```
                    0u32.to_string()
```
Insertion in pijul/src/remote/http.rs at line 511 [13.10]
[15.3448]
[15.3448]
```
            debug!("kv = {:?} {:?}", k, v);
```

Replacement in pijul/src/remote/http.rs at line 524 [13.10]

B:BD[17.12254] → [17.12254:12304]

        let resp: Identities = res.json().await?;

[17.12254]

[17.12304]

        let resp: Option<Identities> = res.json().await?;

Replacement in pijul/src/remote/http.rs at line 526 [13.10]

B:BD[17.12305] → [17.12305:12543]

B:BD[17.12543] → [18.266:342]

∅:D[18.342] → [17.12605:12629]

B:BD[17.12605] → [17.12605:12629]

        std::fs::create_dir_all(&path)?;
        for id in resp.id.iter() {
            path.push(&id.public_key.key);
            debug!("recv identity: {:?} {:?}", id, path);
            let mut id_file = std::fs::File::create(&path)?;
            serde_json::to_writer_pretty(&mut id_file, &id.as_portable())?;
            path.pop();

[17.12305]

[17.12629]

        if let Some(resp) = resp {
            std::fs::create_dir_all(&path)?;
            for id in resp.id.iter() {
                path.push(&id.public_key.key);
                debug!("recv identity: {:?} {:?}", id, path);
                let mut id_file = std::fs::File::create(&path)?;
                serde_json::to_writer_pretty(&mut id_file, &id.as_portable())?;
                path.pop();
            }
            Ok(resp.rev)
        } else {
            Ok(0)

Replacement in pijul/src/remote/http.rs at line 539 [13.10]

B:BD[17.12639] → [17.12639:12660]

        Ok(resp.rev)

[17.12639]

[16.6503]

    }
    pub async fn prove(
        &mut self,
        key: libpijul::key::SKey,
    ) -> Result<(), anyhow::Error> {
        debug!("prove {:?}", self.url);
        let url = format!("{}/{}", self.url, super::DOT_DIR);
        let q = [("challenge", key.public_key().key)];
        let mut req = self
            .client
            .get(&url)
            .query(&q)
            .header(reqwest::header::USER_AGENT, USER_AGENT);
        for (k, v) in self.headers.iter() {
            debug!("kv = {:?} {:?}", k, v);
            req = req.header(k.as_str(), v.as_str());
        }
        let res = req.send().await?;
        if !res.status().is_success() {
            bail!("HTTP error {:?}", res.status())
        }
        let resp = res.bytes().await?;
        debug!("resp = {:?}", resp);
        let sig = key.sign_raw(&resp)?;
        debug!("sig = {:?}", sig);
        let q = [("prove", &sig)];
        let mut req = self
            .client
            .get(&url)
            .query(&q)
            .header(reqwest::header::USER_AGENT, USER_AGENT);
        for (k, v) in self.headers.iter() {
            debug!("kv = {:?} {:?}", k, v);
            req = req.header(k.as_str(), v.as_str());
        }
        let res = req.send().await?;
        if !res.status().is_success() {
            bail!("HTTP error {:?}", res.status())
        }
        Ok(())

Insertion in pijul/src/main.rs at line 136 [9.83981]

[19.313]

[3.0]


    /// Authenticates with a HTTP server.
    Client(Client),

Insertion in pijul/src/main.rs at line 272 [9.83981]

[19.683]

[20.600]

        SubCommand::Client(client) => client.run().await,

Replacement in pijul/src/identity/create.rs at line 125 [21.28175]

B:BD[4.974] → [4.974:1043]

                        .prove(*NO_CERT_CHECK.get_or_init(|| false))

[4.974]

[4.1043]

                        .prove(None, *NO_CERT_CHECK.get_or_init(|| false))

Replacement in pijul/src/identity/create.rs at line 300 [21.28175]

B:BD[21.36896] → [21.36896:36978]

    pub async fn prove(&self, no_cert_check: bool) -> Result<(), anyhow::Error> {

[21.36896]

[21.36978]

    pub async fn prove(
        &self,
        origin: Option<&str>,
        no_cert_check: bool,
    ) -> Result<(), anyhow::Error> {
        let remote = origin.unwrap_or(&self.config.author.origin);

Replacement in pijul/src/identity/create.rs at line 310 [21.28175]

B:BD[4.1638] → [4.1638:1719]

            &self.name, &self.config.author.username, &self.config.author.origin

[4.1638]

[21.37154]

            &self.name, &self.config.author.username, remote

Deletion in pijul/src/identity/create.rs at line 313 [21.28175]
B:BD[21.37167] → [18.13815:13871]
```
        let remote = self.config.author.origin.clone();
```

Replacement in pijul/src/identity/create.rs at line 314 [21.28175]

B:BD[21.37291] → [21.37291:37432]

B:BD[21.37432] → [5.746:802]

∅:D[5.802] → [21.37432:37505]

B:BD[21.37432] → [21.37432:37505]

B:BD[21.37542] → [21.37542:37767]

B:BD[21.37767] → [5.803:926]

∅:D[5.926] → [21.37854:38042]

B:BD[21.37854] → [21.37854:38042]

            use crate::remote::RemoteRepo;
            if let RemoteRepo::Ssh(ssh) = repo
                .remote(
                    None,
                    Some(&self.config.author.username),
                    &remote,
                    crate::DEFAULT_CHANNEL,
                    no_cert_check,
                    false,
                )
                .await?
            {
                ssh
            } else {
                bail!("No such remote: {}", remote)
            }
        } else if let Some(mut ssh) = crate::remote::ssh::ssh_remote(Some(&self.config.author.username), &remote, false) {
            if let Some(c) = ssh.connect(&remote, crate::DEFAULT_CHANNEL).await? {
                c
            } else {
                bail!("No such remote: {}", remote)
            }

[21.37291]

[21.38042]

            repo.remote(
                None,
                Some(&self.config.author.username),
                &remote,
                crate::DEFAULT_CHANNEL,
                no_cert_check,
                false,
            )
            .await?

Replacement in pijul/src/identity/create.rs at line 324 [21.28175]

B:BD[21.38059] → [21.38059:38107]

            bail!("No such remote: {}", remote)

[21.38059]

[21.38107]

            crate::remote::unknown_remote(
                None,
                Some(&self.config.author.username),
                &remote,
                crate::DEFAULT_CHANNEL,
                no_cert_check,
                false,
            )
            .await?

Replacement in pijul/src/config.rs at line 206 [9.89866]
B:BD[15.4809] → [15.4809:4848]
```
    Ok(String::from_utf8(out.stdout)?)
```
[15.4809]
[15.4848]
```
    Ok(String::from_utf8(out.stdout)?.trim().to_string())
```
Deletion in pijul/src/commands/mod.rs at line 65 [9.133619]
∅:D[22.2548] → [23.18549:18577]
B:BD[24.91] → [23.18549:18577]
```
// #[cfg(debug_assertions)]
```
Deletion in pijul/src/commands/mod.rs at line 66 [9.133619]
B:BD[9.134289] → [23.18578:18606]
```
// #[cfg(debug_assertions)]
```
Insertion in pijul/src/commands/mod.rs at line 68 [9.133619]
[9.134333]
[25.138]
```
mod client;
pub use client::*;
```
Insertion in pijul/src/commands/identity.rs at line 167 [21.40825]
[21.46469]
[21.46469]
```
        /// Set the target server
        server: Option<String>,
```
Insertion in pijul/src/commands/identity.rs at line 268 [21.40825]
[21.49543]
[21.49543]
```
                server,
```

Replacement in pijul/src/commands/identity.rs at line 272 [21.40825]

B:BD[21.49687] → [21.49687:49734]

                    .prove(self.no_cert_check)

[21.49687]

[21.49734]

                    .prove(server.as_deref(), self.no_cert_check)

File addition: client.rs (----------)

[9.93386]

use clap::Parser;
use std::convert::Infallible;
use std::net::SocketAddr;
use hyper::{Body, Request, Response, Server};
use hyper::service::{make_service_fn, service_fn};
use tokio::sync::mpsc::channel;
use tokio::select;
use crate::config::global_config_dir;
#[derive(Parser, Debug)]
pub struct Client {
    /// Url to authenticate to.
    #[clap(value_name = "URL")]
    url: String,
}
impl Client {
    pub async fn run(self) -> Result<(), anyhow::Error> {
        let url = url::Url::parse(&self.url)?;
        let mut cache_path = None;
        if let Some(mut cached) = global_config_dir() {
            cached.push("cache");
            if let Some(host) = url.host_str() {
                std::fs::create_dir_all(&cached)?;
                cached.push(host);
                if let Ok(token) = std::fs::read_to_string(&cached) {
                    println!("Bearer {}", token);
                    return Ok(())
                } else {
                    cache_path = Some(cached);
                }
            }
        }
        let (tx, mut rx) = channel::<String>(1);
        let make_service = make_service_fn(|_conn| {
            let tx = tx.clone();
            async move {
                let handle = move |req: Request<_>| {
                    let qq: Option<String> = if let Some(q) = req.uri().query() {
                        let eq = "token=";
                        if q.starts_with(eq) {
                            Some(q.split_at(eq.len()).1.to_string())
                        } else {
                            None
                        }
                    } else {
                        None
                    };
                    let tx = tx.clone();
                    async move {
                        if let Some(qq) = qq {
                            tx.send(qq).await.unwrap();
                            let resp = Response::builder()
                                .header("Content-Type", "text/html")
                                .body(Body::from(include_str!("client.html")))
                                .unwrap();
                            Ok::<_, Infallible>(resp)
                        } else {
                            Ok::<_, Infallible>(
                                Response::builder()
                                    .status(404)
                                    .body("Not found".into())
                                    .unwrap()
                            )
                        }
                    }
                };
                Ok::<_, Infallible>(service_fn(handle))
            }
        });
        let mut port = 3000;
        loop {
            let addr = SocketAddr::from(([127, 0, 0, 1], port));
            if let Ok(server) = Server::try_bind(&addr) {
                let mut url = url::Url::parse(&self.url)?;
                url.query_pairs_mut().append_pair("port", &port.to_string());
                open::that(&url.to_string())?;
                let server = server.serve(make_service);
                select!{
                    x = server => {
                        if let Err(e) = x {
                            eprintln!("server error: {}", e);
                        }
                        break
                    }
                    x = rx.recv() => {
                        if let Some(x) = x {
                            if let Some(cache_path) = cache_path {
                                std::fs::write(&cache_path, &x)?;
                            }
                            println!("Bearer {}", x);
                        }
                        break
                    }
                }
            }
            if port < u16::MAX {
                port += 1
            } else {
                break
            }
        }
        Ok(())
    }
}

Insertion in pijul/Cargo.toml at line 77 [9.196374]
[26.1679]
[17.25010]
```
hyper = { version = "0.14", features = [ "server" ] }
```
Replacement in pijul/Cargo.toml at line 98 [9.196374]
∅:D[2.17] → [27.2288:2300]
∅:D[28.301] → [27.2288:2300]
B:BD[29.472] → [27.2288:2300]
```
url = "2.2"
```
[2.17]
[30.4195]
```
url = "2.3"
```
Insertion in pijul/Cargo.toml at line 111 [9.196374]
[8.279]
[31.309]
```
open = "3"
bs58 = "0.4"
```

new command `pijul client` for authenticating to a HTTP server

Dependencies

In channels

Change contents

Replacement in pijul/src/remote/ssh.rs at line 249 [9.25380]

Replacement in pijul/src/remote/ssh.rs at line 256 [9.25380]

Insertion in pijul/src/remote/mod.rs at line 1121 [9.52474]

Replacement in pijul/src/remote/http.rs at line 41 [13.10]

Replacement in pijul/src/remote/http.rs at line 43 [13.10]

Insertion in pijul/src/remote/http.rs at line 75 [13.10]

Replacement in pijul/src/remote/http.rs at line 92 [13.10]

Replacement in pijul/src/remote/http.rs at line 126 [13.10]

Replacement in pijul/src/remote/http.rs at line 130 [13.10]

Replacement in pijul/src/remote/http.rs at line 133 [13.10]

Replacement in pijul/src/remote/http.rs at line 141 [13.10]

Insertion in pijul/src/remote/http.rs at line 272 [13.10]

Insertion in pijul/src/remote/http.rs at line 325 [13.10]

Insertion in pijul/src/remote/http.rs at line 343 [13.10]

Insertion in pijul/src/remote/http.rs at line 359 [13.10]

Insertion in pijul/src/remote/http.rs at line 384 [13.10]

Insertion in pijul/src/remote/http.rs at line 418 [13.10]

Replacement in pijul/src/remote/http.rs at line 504 [13.10]

Replacement in pijul/src/remote/http.rs at line 506 [13.10]

Insertion in pijul/src/remote/http.rs at line 511 [13.10]

Replacement in pijul/src/remote/http.rs at line 524 [13.10]

Replacement in pijul/src/remote/http.rs at line 526 [13.10]

Replacement in pijul/src/remote/http.rs at line 539 [13.10]

Insertion in pijul/src/main.rs at line 136 [9.83981]

Insertion in pijul/src/main.rs at line 272 [9.83981]

Replacement in pijul/src/identity/create.rs at line 125 [21.28175]

Replacement in pijul/src/identity/create.rs at line 300 [21.28175]

Replacement in pijul/src/identity/create.rs at line 310 [21.28175]

Deletion in pijul/src/identity/create.rs at line 313 [21.28175]

Replacement in pijul/src/identity/create.rs at line 314 [21.28175]

Replacement in pijul/src/identity/create.rs at line 324 [21.28175]

Replacement in pijul/src/config.rs at line 206 [9.89866]

Deletion in pijul/src/commands/mod.rs at line 65 [9.133619]

Deletion in pijul/src/commands/mod.rs at line 66 [9.133619]

Insertion in pijul/src/commands/mod.rs at line 68 [9.133619]

Insertion in pijul/src/commands/identity.rs at line 167 [21.40825]

Insertion in pijul/src/commands/identity.rs at line 268 [21.40825]

Replacement in pijul/src/commands/identity.rs at line 272 [21.40825]

File addition: client.rs (----------)

Insertion in pijul/Cargo.toml at line 77 [9.196374]

Replacement in pijul/Cargo.toml at line 98 [9.196374]

Insertion in pijul/Cargo.toml at line 111 [9.196374]