···

       
6
       
 
       
use crate::sources::*;

     

       
7
       
 
       


     

       
8
       
 
       
use rayon::prelude::*;

     

       
0
       
 
       

     

       
9
       
 
       


     

       
10
       
 
       
#[derive(Debug, serde::Deserialize)]

     

       
11
       
 
       
pub struct Entry {

     
···

       
14
       
 
       
}

     

       
15
       
 
       


     

       
16
       
 
       
impl Entry {

     

       
17
       
-
       
    pub fn fetch(&self) -> (String, Vec<ssh_key::PublicKey>) {

     

       
18
       
-
       
        let mut stream: Vec<_> = self.keys.par_iter().map(|k| k.fetch()).flatten().collect();

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
19
       
 
       


     

       
20
       
 
       
        // Deduplicate keys, no need for duplicated entries

     

       
21
       
 
       
        stream.sort();

     

       
22
       
 
       
        stream.dedup_by(|a, b| a.key_data() == b.key_data());

     

       
23
       
 
       


     

       
24
       
-
       
        (self.name.clone(), stream)

     

       
25
       
 
       
    }

     

       
26
       
 
       
}

     

       
27
       
 
       


     
···

       
32
       
 
       
}

     

       
33
       
 
       


     

       
34
       
 
       
impl Config {

     

       
35
       
-
       
    pub fn fetch(&self) -> Result<Output, ()> {

     

       
36
       
-
       
        let keys = self.entries.into_par_iter().map(Entry::fetch).collect();

     

       
37
       
-
       


     

       
38
       
-
       
        Ok(Output { keys })

     

       
39
       
 
       
    }

     

       
40
       
 
       
}

     

···

       
6
       
 
       
use crate::sources::*;

     

       
7
       
 
       


     

       
8
       
 
       
use rayon::prelude::*;

     

       
9
       
+
       
use simple_eyre::eyre::Result;

     

       
10
       
 
       


     

       
11
       
 
       
#[derive(Debug, serde::Deserialize)]

     

       
12
       
 
       
pub struct Entry {

     
···

       
15
       
 
       
}

     

       
16
       
 
       


     

       
17
       
 
       
impl Entry {

     

       
18
       
+
       
    pub fn fetch(&self) -> Result<(String, Vec<ssh_key::PublicKey>)> {

     

       
19
       
+
       
        let mut stream: Vec<ssh_key::PublicKey> = self

     

       
20
       
+
       
            .keys

     

       
21
       
+
       
            .par_iter()

     

       
22
       
+
       
            .flat_map(|k| k.fetch().unwrap())

     

       
23
       
+
       
            .collect();

     

       
24
       
 
       


     

       
25
       
 
       
        // Deduplicate keys, no need for duplicated entries

     

       
26
       
 
       
        stream.sort();

     

       
27
       
 
       
        stream.dedup_by(|a, b| a.key_data() == b.key_data());

     

       
28
       
 
       


     

       
29
       
+
       
        Ok((self.name.clone(), stream))

     

       
30
       
 
       
    }

     

       
31
       
 
       
}

     

       
32
       
 
       


     
···

       
37
       
 
       
}

     

       
38
       
 
       


     

       
39
       
 
       
impl Config {

     

       
40
       
+
       
    pub fn fetch(&self) -> Result<Output> {

     

       
41
       
+
       
        self.entries.into_par_iter().map(Entry::fetch).collect()

     

       
0
       
 
       

     

       
0
       
 
       

     

       
42
       
 
       
    }

     

       
43
       
 
       
}

     

···

       
5
       
 
       
use std::collections::HashMap;

     

       
6
       
 
       
use std::io::{self, prelude::*};

     

       
7
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
8
       
 
       
#[derive(PartialEq, Eq, Debug, Copy, Clone)]

     

       
9
       
 
       
pub enum Format {

     

       
10
       
 
       
    JSON,

     
···

       
18
       
 
       
        match self {

     

       
19
       
 
       
            Format::JSON => {

     

       
20
       
 
       
                serde_json::to_writer_pretty(&mut *w, &output.keys).map_err(io::Error::other)?;

     

       
21
       
-
       
                writeln!(w, "")

     

       
22
       
 
       
            }

     

       
23
       
 
       
            Format::TOML => write!(w, "{}", toml::to_string_pretty(&output.keys).unwrap()),

     

       
24
       
 
       
            Format::CSV => as_csv(w, output),

     
···

       
53
       
 
       
#[derive(Debug, serde::Serialize)]

     

       
54
       
 
       
pub struct Output {

     

       
55
       
 
       
    pub keys: HashMap<String, Vec<ssh_key::PublicKey>>,

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
56
       
 
       
}

     

       
57
       
 
       


     

       
58
       
 
       
// TODO: proper escaping

     

···

       
5
       
 
       
use std::collections::HashMap;

     

       
6
       
 
       
use std::io::{self, prelude::*};

     

       
7
       
 
       


     

       
8
       
+
       
use rayon::prelude::*;

     

       
9
       
+
       


     

       
10
       
 
       
#[derive(PartialEq, Eq, Debug, Copy, Clone)]

     

       
11
       
 
       
pub enum Format {

     

       
12
       
 
       
    JSON,

     
···

       
20
       
 
       
        match self {

     

       
21
       
 
       
            Format::JSON => {

     

       
22
       
 
       
                serde_json::to_writer_pretty(&mut *w, &output.keys).map_err(io::Error::other)?;

     

       
23
       
+
       
                writeln!(w)

     

       
24
       
 
       
            }

     

       
25
       
 
       
            Format::TOML => write!(w, "{}", toml::to_string_pretty(&output.keys).unwrap()),

     

       
26
       
 
       
            Format::CSV => as_csv(w, output),

     
···

       
55
       
 
       
#[derive(Debug, serde::Serialize)]

     

       
56
       
 
       
pub struct Output {

     

       
57
       
 
       
    pub keys: HashMap<String, Vec<ssh_key::PublicKey>>,

     

       
58
       
+
       
}

     

       
59
       
+
       


     

       
60
       
+
       
impl FromParallelIterator<(String, Vec<ssh_key::PublicKey>)> for Output {

     

       
61
       
+
       
    fn from_par_iter<T>(iter: T) -> Self

     

       
62
       
+
       
    where

     

       
63
       
+
       
        T: IntoParallelIterator<Item = (String, Vec<ssh_key::PublicKey>)>,

     

       
64
       
+
       
    {

     

       
65
       
+
       
        Output {

     

       
66
       
+
       
            keys: iter.into_par_iter().collect(),

     

       
67
       
+
       
        }

     

       
68
       
+
       
    }

     

       
69
       
 
       
}

     

       
70
       
 
       


     

       
71
       
 
       
// TODO: proper escaping

     

···

       
8
       
 
       
use super::helpers;

     

       
9
       
 
       


     

       
10
       
 
       
use serde::Deserialize;

     

       
0
       
 
       

     

       
11
       
 
       
use ssh_key::PublicKey;

     

       
12
       
 
       


     

       
13
       
 
       
#[derive(Debug)]

     

       
14
       
-
       
pub struct DID {

     

       
15
       
 
       
    method: String,

     

       
16
       
 
       
    id: String,

     

       
17
       
 
       
}

     

       
18
       
 
       


     

       
19
       
-
       
impl FromStr for DID {

     

       
20
       
 
       
    type Err = ();

     

       
21
       
 
       


     

       
22
       
 
       
    fn from_str(input: &str) -> Result<Self, ()> {

     
···

       
33
       
 
       
            return Err(());

     

       
34
       
 
       
        }

     

       
35
       
 
       


     

       
36
       
-
       
        Ok(DID {

     

       
37
       
 
       
            method: chunks[1].into(),

     

       
38
       
 
       
            id: chunks[2].into(),

     

       
39
       
 
       
        })

     

       
40
       
 
       
    }

     

       
41
       
 
       
}

     

       
42
       
 
       


     

       
43
       
-
       
impl fmt::Display for DID {

     

       
44
       
 
       
    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {

     

       
45
       
 
       
        write!(f, "did:{}:{}", self.method, self.id)

     

       
46
       
 
       
    }

     
···

       
82
       
 
       
            return Err(());

     

       
83
       
 
       
        }

     

       
84
       
 
       


     

       
85
       
-
       
        if (b'0'..=b'9').contains(&segments.last().unwrap().as_bytes()[0]) {

     

       
86
       
 
       
            return Err(());

     

       
87
       
 
       
        }

     

       
88
       
 
       


     
···

       
100
       
 
       


     

       
101
       
 
       
#[derive(Debug)]

     

       
102
       
 
       
pub enum Identifier {

     

       
103
       
-
       
    DID(DID),

     

       
104
       
 
       
    Handle(Handle),

     

       
105
       
 
       
}

     

       
106
       
 
       


     
···

       
110
       
 
       
    fn from_str(input: &str) -> Result<Self, Self::Err> {

     

       
111
       
 
       
        input

     

       
112
       
 
       
            .parse()

     

       
113
       
-
       
            .map(Identifier::DID)

     

       
114
       
 
       
            .or_else(|_| input.parse().map(Identifier::Handle))

     

       
115
       
 
       
            .map_err(|_| InvalidHandle(input.into()))

     

       
116
       
 
       
    }

     
···

       
119
       
 
       
impl fmt::Display for Identifier {

     

       
120
       
 
       
    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {

     

       
121
       
 
       
        match *self {

     

       
122
       
-
       
            Identifier::DID(ref did) => write!(f, "{}", did),

     

       
123
       
 
       
            Identifier::Handle(ref handle) => write!(f, "{}", handle),

     

       
124
       
 
       
        }

     

       
125
       
 
       
    }

     
···

       
146
       
 
       


     

       
147
       
 
       
fn legal_segment(segment: &str) -> bool {

     

       
148
       
 
       
    let bytes = segment.as_bytes();

     

       
149
       
-
       
    segment != ""

     

       
150
       
-
       
        && bytes.into_iter().all(|&b| allowed_byte(b))

     

       
151
       
 
       
        && *bytes.first().unwrap() != b'-'

     

       
152
       
 
       
        && *bytes.last().unwrap() != b'-'

     

       
153
       
 
       
}

     

       
154
       
 
       


     

       
155
       
 
       
fn allowed_byte(c: u8) -> bool {

     

       
156
       
-
       
    (b'0'..=b'9').contains(&c) || (b'a'..=b'z').contains(&c) || c == b'-'

     

       
157
       
 
       
}

     

       
158
       
 
       


     

       
159
       
 
       
fn default_atproto() -> String {

     
···

       
179
       
 
       
        key: String,

     

       
180
       
 
       
    }

     

       
181
       
 
       


     

       
182
       
-
       
    impl Into<PublicKey> for &Record {

     

       
183
       
-
       
        fn into(self) -> PublicKey {

     

       
184
       
-
       
            PublicKey::from_openssh(&self.value.key).unwrap()

     

       
0
       
 
       

     

       
0
       
 
       

     

       
185
       
 
       
        }

     

       
186
       
 
       
    }

     

       
187
       
 
       
}

     

       
188
       
 
       


     

       
189
       
 
       
impl super::Fetch for ATProto {

     

       
190
       
-
       
    fn fetch(&self) -> Vec<PublicKey> {

     

       
191
       
-
       
        let mut url = url::Url::parse(&self.host).unwrap();

     

       
192
       
 
       


     

       
193
       
 
       
        url.query_pairs_mut()

     

       
194
       
 
       
            .append_pair("repo", &self.handle.to_string())

     
···

       
197
       
 
       
        url.set_path("xrpc/com.atproto.repo.listRecords");

     

       
198
       
 
       


     

       
199
       
 
       
        let data = ureq::get(&url.to_string())

     

       
200
       
-
       
            .call()

     

       
201
       
-
       
            .unwrap()

     

       
202
       
 
       
            .body_mut()

     

       
203
       
-
       
            .read_to_string()

     

       
204
       
-
       
            .unwrap();

     

       
205
       
 
       


     

       
206
       
-
       
        let decoded: resp::Resp = serde_json::from_str(&data).unwrap();

     

       
207
       
 
       


     

       
208
       
-
       
        decoded.records.iter().map(Into::into).collect()

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
209
       
 
       
    }

     

       
210
       
 
       
}

     

···

       
8
       
 
       
use super::helpers;

     

       
9
       
 
       


     

       
10
       
 
       
use serde::Deserialize;

     

       
11
       
+
       
use simple_eyre::eyre::Result;

     

       
12
       
 
       
use ssh_key::PublicKey;

     

       
13
       
 
       


     

       
14
       
 
       
#[derive(Debug)]

     

       
15
       
+
       
pub struct Did {

     

       
16
       
 
       
    method: String,

     

       
17
       
 
       
    id: String,

     

       
18
       
 
       
}

     

       
19
       
 
       


     

       
20
       
+
       
impl FromStr for Did {

     

       
21
       
 
       
    type Err = ();

     

       
22
       
 
       


     

       
23
       
 
       
    fn from_str(input: &str) -> Result<Self, ()> {

     
···

       
34
       
 
       
            return Err(());

     

       
35
       
 
       
        }

     

       
36
       
 
       


     

       
37
       
+
       
        Ok(Did {

     

       
38
       
 
       
            method: chunks[1].into(),

     

       
39
       
 
       
            id: chunks[2].into(),

     

       
40
       
 
       
        })

     

       
41
       
 
       
    }

     

       
42
       
 
       
}

     

       
43
       
 
       


     

       
44
       
+
       
impl fmt::Display for Did {

     

       
45
       
 
       
    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {

     

       
46
       
 
       
        write!(f, "did:{}:{}", self.method, self.id)

     

       
47
       
 
       
    }

     
···

       
83
       
 
       
            return Err(());

     

       
84
       
 
       
        }

     

       
85
       
 
       


     

       
86
       
+
       
        if segments.last().unwrap().as_bytes()[0].is_ascii_digit() {

     

       
87
       
 
       
            return Err(());

     

       
88
       
 
       
        }

     

       
89
       
 
       


     
···

       
101
       
 
       


     

       
102
       
 
       
#[derive(Debug)]

     

       
103
       
 
       
pub enum Identifier {

     

       
104
       
+
       
    Did(Did),

     

       
105
       
 
       
    Handle(Handle),

     

       
106
       
 
       
}

     

       
107
       
 
       


     
···

       
111
       
 
       
    fn from_str(input: &str) -> Result<Self, Self::Err> {

     

       
112
       
 
       
        input

     

       
113
       
 
       
            .parse()

     

       
114
       
+
       
            .map(Identifier::Did)

     

       
115
       
 
       
            .or_else(|_| input.parse().map(Identifier::Handle))

     

       
116
       
 
       
            .map_err(|_| InvalidHandle(input.into()))

     

       
117
       
 
       
    }

     
···

       
120
       
 
       
impl fmt::Display for Identifier {

     

       
121
       
 
       
    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {

     

       
122
       
 
       
        match *self {

     

       
123
       
+
       
            Identifier::Did(ref did) => write!(f, "{}", did),

     

       
124
       
 
       
            Identifier::Handle(ref handle) => write!(f, "{}", handle),

     

       
125
       
 
       
        }

     

       
126
       
 
       
    }

     
···

       
147
       
 
       


     

       
148
       
 
       
fn legal_segment(segment: &str) -> bool {

     

       
149
       
 
       
    let bytes = segment.as_bytes();

     

       
150
       
+
       
    !segment.is_empty()

     

       
151
       
+
       
        && bytes.iter().all(|&b| allowed_byte(b))

     

       
152
       
 
       
        && *bytes.first().unwrap() != b'-'

     

       
153
       
 
       
        && *bytes.last().unwrap() != b'-'

     

       
154
       
 
       
}

     

       
155
       
 
       


     

       
156
       
 
       
fn allowed_byte(c: u8) -> bool {

     

       
157
       
+
       
    c.is_ascii_digit() || c.is_ascii_lowercase() || c == b'-'

     

       
158
       
 
       
}

     

       
159
       
 
       


     

       
160
       
 
       
fn default_atproto() -> String {

     
···

       
180
       
 
       
        key: String,

     

       
181
       
 
       
    }

     

       
182
       
 
       


     

       
183
       
+
       
    impl TryFrom<&Record> for PublicKey {

     

       
184
       
+
       
        type Error = ssh_key::Error;

     

       
185
       
+
       


     

       
186
       
+
       
        fn try_from(val: &Record) -> ssh_key::Result<PublicKey> {

     

       
187
       
+
       
            PublicKey::from_openssh(&val.value.key)

     

       
188
       
 
       
        }

     

       
189
       
 
       
    }

     

       
190
       
 
       
}

     

       
191
       
 
       


     

       
192
       
 
       
impl super::Fetch for ATProto {

     

       
193
       
+
       
    fn fetch(&self) -> Result<Vec<PublicKey>> {

     

       
194
       
+
       
        let mut url = url::Url::parse(&self.host)?;

     

       
195
       
 
       


     

       
196
       
 
       
        url.query_pairs_mut()

     

       
197
       
 
       
            .append_pair("repo", &self.handle.to_string())

     
···

       
200
       
 
       
        url.set_path("xrpc/com.atproto.repo.listRecords");

     

       
201
       
 
       


     

       
202
       
 
       
        let data = ureq::get(&url.to_string())

     

       
203
       
+
       
            .call()?

     

       
0
       
 
       

     

       
204
       
 
       
            .body_mut()

     

       
205
       
+
       
            .read_to_string()?;

     

       
0
       
 
       

     

       
206
       
 
       


     

       
207
       
+
       
        let decoded: resp::Resp = serde_json::from_str(&data)?;

     

       
208
       
 
       


     

       
209
       
+
       
        decoded

     

       
210
       
+
       
            .records

     

       
211
       
+
       
            .iter()

     

       
212
       
+
       
            .map(|val| val.try_into().map_err(Into::into))

     

       
213
       
+
       
            .collect()

     

       
214
       
 
       
    }

     

       
215
       
 
       
}

     

···

       
5
       
 
       
use std::fmt;

     

       
6
       
 
       
use std::str::FromStr;

     

       
7
       
 
       


     

       
8
       
-
       
use serde::{de, Deserialize, Deserializer};

     

       
9
       
 
       


     

       
10
       
 
       
pub fn string_or_struct<'de, T, D>(deserializer: D) -> Result<T, D::Error>

     

       
11
       
 
       
where

     
···

       
61
       
 
       
{

     

       
62
       
 
       
    struct DeFromStr<T>(std::marker::PhantomData<T>);

     

       
63
       
 
       


     

       
64
       
-
       
    impl<'de, T> de::Visitor<'de> for DeFromStr<T>

     

       
65
       
 
       
    where

     

       
66
       
 
       
        T: FromStr,

     

       
67
       
 
       
        <T as FromStr>::Err: fmt::Display,

     

···

       
5
       
 
       
use std::fmt;

     

       
6
       
 
       
use std::str::FromStr;

     

       
7
       
 
       


     

       
8
       
+
       
use serde::{Deserialize, Deserializer, de};

     

       
9
       
 
       


     

       
10
       
 
       
pub fn string_or_struct<'de, T, D>(deserializer: D) -> Result<T, D::Error>

     

       
11
       
 
       
where

     
···

       
61
       
 
       
{

     

       
62
       
 
       
    struct DeFromStr<T>(std::marker::PhantomData<T>);

     

       
63
       
 
       


     

       
64
       
+
       
    impl<T> de::Visitor<'_> for DeFromStr<T>

     

       
65
       
 
       
    where

     

       
66
       
 
       
        T: FromStr,

     

       
67
       
 
       
        <T as FromStr>::Err: fmt::Display,

     

···

       
4
       
 
       
// SPDX-License-Identifier: EUPL-1.2

     

       
5
       
 
       


     

       
6
       
 
       
use serde::Deserialize;

     

       
0
       
 
       

     

       
7
       
 
       
use ssh_key::PublicKey;

     

       
8
       
 
       
use std::process::Command;

     

       
9
       
 
       


     
···

       
13
       
 
       
pub use atproto::ATProto;

     

       
14
       
 
       


     

       
15
       
 
       
pub trait Fetch: std::fmt::Debug {

     

       
16
       
-
       
    fn fetch(&self) -> Vec<PublicKey>;

     

       
17
       
 
       
}

     

       
18
       
 
       


     

       
19
       
 
       
#[derive(Debug, Deserialize)]

     
···

       
32
       
 
       
}

     

       
33
       
 
       


     

       
34
       
 
       
impl Fetch for Source {

     

       
35
       
-
       
    fn fetch(&self) -> Vec<PublicKey> {

     

       
36
       
 
       
        match *self {

     

       
37
       
 
       
            Source::Raw(ref raw) => raw.fetch(),

     

       
38
       
 
       
            Source::Hosts(ref raw) => raw.fetch(),

     
···

       
58
       
 
       
    }

     

       
59
       
 
       
}

     

       
60
       
 
       


     

       
61
       
-
       
fn normalize_sourcehut<'a>(s: &'a str) -> std::borrow::Cow<'a, str> {

     

       
62
       
 
       
    if s.starts_with("~") {

     

       
63
       
 
       
        s.into()

     

       
64
       
 
       
    } else {

     
···

       
70
       
 
       
pub struct Raw(Box<[PublicKey]>);

     

       
71
       
 
       


     

       
72
       
 
       
impl Fetch for Raw {

     

       
73
       
-
       
    fn fetch(&self) -> Vec<PublicKey> {

     

       
74
       
-
       
        self.0.clone().into()

     

       
75
       
 
       
    }

     

       
76
       
 
       
}

     

       
77
       
 
       


     
···

       
79
       
 
       
pub struct Hosts(pub Box<[String]>);

     

       
80
       
 
       


     

       
81
       
 
       
impl Fetch for Hosts {

     

       
82
       
-
       
    fn fetch(&self) -> Vec<PublicKey> {

     

       
83
       
 
       
        // TODO: Check if we can do it in-process instead of shelling out to `ssh-keyscan`

     

       
84
       
 
       
        let result = Command::new("ssh-keyscan").args(&self.0).output().unwrap();

     

       
85
       
 
       


     

       
86
       
-
       
        std::str::from_utf8(&result.stdout)

     

       
87
       
-
       
            .unwrap()

     

       
88
       
 
       
            .trim()

     

       
89
       
 
       
            .split('\n')

     

       
90
       
 
       
            .map(str::trim)

     
···

       
93
       
 
       
            // Ignore first column as it contain hostname which is not

     

       
94
       
 
       
            // needed there

     

       
95
       
 
       
            .map(|line| line.split_once(' ').unwrap().1)

     

       
96
       
-
       
            .map(|k| PublicKey::from_openssh(&k).unwrap())

     

       
97
       
 
       
            .collect()

     

       
98
       
 
       
    }

     

       
99
       
 
       
}

     
···

       
104
       
 
       
}

     

       
105
       
 
       


     

       
106
       
 
       
impl Fetch for Http {

     

       
107
       
-
       
    fn fetch(&self) -> Vec<PublicKey> {

     

       
108
       
 
       
        ureq::get(&self.url)

     

       
109
       
-
       
            .call()

     

       
110
       
-
       
            .unwrap()

     

       
111
       
 
       
            .body_mut()

     

       
112
       
-
       
            .read_to_string()

     

       
113
       
-
       
            .unwrap()

     

       
114
       
 
       
            .trim()

     

       
115
       
 
       
            .split('\n')

     

       
116
       
-
       
            .map(|s| PublicKey::from_openssh(s).unwrap())

     

       
117
       
 
       
            .collect()

     

       
118
       
 
       
    }

     

       
119
       
 
       
}

     

···

       
4
       
 
       
// SPDX-License-Identifier: EUPL-1.2

     

       
5
       
 
       


     

       
6
       
 
       
use serde::Deserialize;

     

       
7
       
+
       
use simple_eyre::eyre::Result;

     

       
8
       
 
       
use ssh_key::PublicKey;

     

       
9
       
 
       
use std::process::Command;

     

       
10
       
 
       


     
···

       
14
       
 
       
pub use atproto::ATProto;

     

       
15
       
 
       


     

       
16
       
 
       
pub trait Fetch: std::fmt::Debug {

     

       
17
       
+
       
    fn fetch(&self) -> Result<Vec<PublicKey>>;

     

       
18
       
 
       
}

     

       
19
       
 
       


     

       
20
       
 
       
#[derive(Debug, Deserialize)]

     
···

       
33
       
 
       
}

     

       
34
       
 
       


     

       
35
       
 
       
impl Fetch for Source {

     

       
36
       
+
       
    fn fetch(&self) -> Result<Vec<PublicKey>> {

     

       
37
       
 
       
        match *self {

     

       
38
       
 
       
            Source::Raw(ref raw) => raw.fetch(),

     

       
39
       
 
       
            Source::Hosts(ref raw) => raw.fetch(),

     
···

       
59
       
 
       
    }

     

       
60
       
 
       
}

     

       
61
       
 
       


     

       
62
       
+
       
fn normalize_sourcehut(s: &str) -> std::borrow::Cow<str> {

     

       
63
       
 
       
    if s.starts_with("~") {

     

       
64
       
 
       
        s.into()

     

       
65
       
 
       
    } else {

     
···

       
71
       
 
       
pub struct Raw(Box<[PublicKey]>);

     

       
72
       
 
       


     

       
73
       
 
       
impl Fetch for Raw {

     

       
74
       
+
       
    fn fetch(&self) -> Result<Vec<PublicKey>> {

     

       
75
       
+
       
        Ok(self.0.clone().into())

     

       
76
       
 
       
    }

     

       
77
       
 
       
}

     

       
78
       
 
       


     
···

       
80
       
 
       
pub struct Hosts(pub Box<[String]>);

     

       
81
       
 
       


     

       
82
       
 
       
impl Fetch for Hosts {

     

       
83
       
+
       
    fn fetch(&self) -> Result<Vec<PublicKey>> {

     

       
84
       
 
       
        // TODO: Check if we can do it in-process instead of shelling out to `ssh-keyscan`

     

       
85
       
 
       
        let result = Command::new("ssh-keyscan").args(&self.0).output().unwrap();

     

       
86
       
 
       


     

       
87
       
+
       
        std::str::from_utf8(&result.stdout)?

     

       
0
       
 
       

     

       
88
       
 
       
            .trim()

     

       
89
       
 
       
            .split('\n')

     

       
90
       
 
       
            .map(str::trim)

     
···

       
93
       
 
       
            // Ignore first column as it contain hostname which is not

     

       
94
       
 
       
            // needed there

     

       
95
       
 
       
            .map(|line| line.split_once(' ').unwrap().1)

     

       
96
       
+
       
            .map(|k| PublicKey::from_openssh(k).map_err(Into::into))

     

       
97
       
 
       
            .collect()

     

       
98
       
 
       
    }

     

       
99
       
 
       
}

     
···

       
104
       
 
       
}

     

       
105
       
 
       


     

       
106
       
 
       
impl Fetch for Http {

     

       
107
       
+
       
    fn fetch(&self) -> Result<Vec<PublicKey>> {

     

       
108
       
 
       
        ureq::get(&self.url)

     

       
109
       
+
       
            .call()?

     

       
0
       
 
       

     

       
110
       
 
       
            .body_mut()

     

       
111
       
+
       
            .read_to_string()?

     

       
0
       
 
       

     

       
112
       
 
       
            .trim()

     

       
113
       
 
       
            .split('\n')

     

       
114
       
+
       
            .map(|s| PublicKey::from_openssh(s).map_err(Into::into))

     

       
115
       
 
       
            .collect()

     

       
116
       
 
       
    }

     

       
117
       
 
       
}