/// Key management
    Key(Key),

        SubCommand::Key(key) => key.run().await,

    pub author: libpijul::change::Author,

    pub author: Author,

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Author {
    pub key_path: String,
    pub short_name: String,
    pub email: Option<String>,
    pub full_name: Option<String>,
}

pub const GLOBAL_CONFIG_DIR: &str = ".pijulconfig";

pub fn global_config_dir() -> Option<PathBuf> {
    if let Some(mut dir) = dirs_next::config_dir() {
        dir.push(CONFIG_DIR);
        Some(dir)
    } else {
        None
    }
}

        if let Some(mut dir) = dirs_next::config_dir() {
            dir.push(CONFIG_DIR);

        if let Some(mut dir) = global_config_dir() {

                        dir.push(".pijulconfig");

                        dir.push(GLOBAL_CONFIG_DIR);

    let authors = if let Some(a) = author {
        vec![libpijul::change::Author {
            name: a.to_string(),
            full_name: None,
            email: None,
        }]
    } else if let Ok(global) = crate::config::Global::load() {
        vec![global.author]
    } else {
        Vec::new()
    };

    let mut authors = Vec::new();
    if let Some(ref a) = author {
        authors.push(a.to_string());
    } else if let Some(mut dir) = crate::config::global_config_dir() {
        dir.push("publickey.json");
        if let Ok(key) = std::fs::File::open(&dir) {
            let k: libpijul::key::PublicKey = serde_json::from_reader(key).unwrap();
            authors.push(k.key)
        }
    }

use log::{debug, error};
use serde_derive::{Deserialize, Serialize};
use thrussh_keys::PublicKeyBase64;

use log::debug;

        let sign = self.sign;

        let key = if let Some(mut dir) = crate::config::global_config_dir() {
            dir.push("secretkey.json");
            if let Ok(key) = std::fs::File::open(&dir) {
                let k: libpijul::key::SecretKey = serde_json::from_reader(key)?;
                let pass = if k.encryption.is_some() {
                    Some(rpassword::read_password_from_tty(Some(&format!(
                        "Password for {:?}: ",
                        dir
                    )))?)
                } else {
                    None
                };
                k.load(pass.as_deref())?
            } else {
                bail!("Secret key not found, please use `pijul key generate` and try again")
            }
        } else {
            bail!("Secret key not found, please use `pijul key generate` and try again")
        };

                if sign {
                    let mut key_path = dirs_next::home_dir().unwrap().join(".ssh");
                    match sign_hash(&mut key_path, hash).await? {
                        Some((pk, signature)) if !signature.is_empty() => {
                            let sig = toml::Value::try_from(vec![Signature {
                                public_key: pk,
                                timestamp: change.header.timestamp,
                                signature,
                            }])?;
                            let mut toml = toml::map::Map::new();
                            toml.insert("signatures".to_string(), sig);
                            change.unhashed = Some(toml.into());
                            let hash2 = repo.changes.save_change(&change).unwrap();
                            assert_eq!(hash2, hash);
                        }
                        _ => {
                            bail!("Could not sign the change");
                        }
                    }
                }

                change.unhashed = Some(serde_json::json!({
                    "signature": key.sign_raw(&hash.to_bytes())?,
                }));

        let authors = if let Some(ref a) = self.author {
            vec![libpijul::change::Author {
                name: a.clone(),
                full_name: None,
                email: None,
            }]
        } else if let Ok(global) = config.as_ref() {
            vec![global.author.clone()]
        } else {
            Vec::new()
        };

        let mut authors = Vec::new();
        if let Some(ref a) = self.author {
            authors.push(a.clone());
        } else if let Some(mut dir) = crate::config::global_config_dir() {
            dir.push("publickey.json");
            if let Ok(key) = std::fs::File::open(&dir) {
                let k: libpijul::key::PublicKey = serde_json::from_reader(key).unwrap();
                authors.push(k.key)
            }
        }

}
#[derive(Debug, Serialize, Deserialize)]
struct Signature {
    public_key: String,
    timestamp: chrono::DateTime<chrono::Utc>,
    signature: String,

async fn sign_hash(
    key_path: &mut PathBuf,
    hash: libpijul::Hash,
) -> Result<Option<(String, String)>, anyhow::Error> {
    let to_sign = hash.to_bytes();
    match thrussh_keys::agent::client::AgentClient::connect_env().await {
        Ok(agent) => {
            let mut agent = Some(agent);
            for k in &["id_ed25519.pub", "id_rsa.pub"] {
                key_path.push(k);
                if let Ok(key) = thrussh_keys::load_public_key(&key_path) {
                    debug!("key");
                    if let Some(a) = agent.take() {
                        debug!("authenticate future");
                        if let (_, Ok(sig)) = a.sign_request_base64(&key, &to_sign).await {
                            key_path.pop();
                            let key = key.public_key_base64();
                            return Ok(Some((key, sig)));
                        }
                    }
                }
                key_path.pop();
            }
        }
        Err(e) => {
            error!("{:?}", e);
        }
    }
    for k in &["id_ed25519", "id_rsa"] {
        key_path.push(k);
        if let Some(k) = crate::remote::ssh::load_secret_key(&key_path, k) {
            key_path.pop();
            let pk = k.public_key_base64();
            return Ok(Some((pk, k.sign_detached(&to_sign)?.to_base64())));
        } else {
            key_path.pop();
        }
    }
    Ok(None)
}

# comment to abort).

# comment) to abort.

    /// Sign the change with the default key
    #[clap(short = 'S')]
    pub sign: bool,

mod key;
pub use key::*;

use crate::config::*;
use anyhow::bail;
use chrono::Datelike;
use clap::Clap;
use log::debug;
use std::io::Write;
use std::path::Path;
#[derive(Clap, Debug)]
pub struct Key {
    #[clap(subcommand)]
    subcmd: Option<SubCommand>,
}
#[derive(Clap, Debug)]
pub enum SubCommand {
    Generate {},
}
impl Key {
    pub async fn run(self) -> Result<(), anyhow::Error> {
        match self.subcmd {
            Some(SubCommand::Generate {}) => {
                if let Some(mut dir) = global_config_dir() {
                    dir.push("secretkey.json");
                    if std::fs::metadata(&dir).is_ok() {
                        bail!("Cannot overwrite key file {:?}", dir)
                    }
                    debug!("creating file {:?}", dir);
                    let mut f = open_secret_file(&dir)?;
                    let expires = chrono::Utc::now();
                    let expires = expires.with_year(expires.year() + 1).unwrap();
                    let pass = rpassword::read_password_from_tty(Some(
                        "Password for the new key (press enter to leave it unencrypted): ",
                    ))?;
                    let pass = if pass.is_empty() {
                        None
                    } else {
                        Some(pass.as_ref())
                    };
                    let k = libpijul::key::SKey::generate(expires);
                    serde_json::to_writer_pretty(&mut f, &k.save(pass))?;
                    f.write_all(b"\n")?;
                    let mut stderr = std::io::stderr();
                    writeln!(stderr, "Wrote secret key in {:?}", dir)?;
                    dir.pop();
                    dir.push("publickey.json");
                    debug!("creating file {:?}", dir);
                    let mut f = std::fs::File::create(&dir)?;
                    serde_json::to_writer_pretty(&mut f, &k.public_key())?;
                    f.write_all(b"\n")?;
                }
            }
            None => {}
        }
        Ok(())
    }
}
#[cfg(unix)]
fn open_secret_file(path: &Path) -> Result<std::fs::File, std::io::Error> {
    use std::fs::OpenOptions;
    use std::os::unix::fs::OpenOptionsExt;
    OpenOptions::new()
        .write(true)
        .create(true)
        .mode(0o600)
        .open(path)
}
#[cfg(not(unix))]
fn open_secret_file(path: &Path) -> Result<std::fs::File, std::io::Error> {
    std::fs::File::create(path)
}

pub mod key;

use hmac::Hmac;
use sha2::{Digest, Sha256};
pub const CONTEXT: &'static [u8] = b"pijul";
pub const VERSION: u64 = 0;
#[derive(Debug, Error)]
pub enum KeyError {
    #[error("Base 32 decoding error")]
    Encoding,
    #[error(transparent)]
    Dalek(#[from] ed25519_dalek::ed25519::Error),
    #[error("No password supplied")]
    NoPassword,
    #[error("The key expired")]
    Expired,
}
impl From<data_encoding::DecodePartial> for KeyError {
    fn from(_: data_encoding::DecodePartial) -> Self {
        KeyError::Encoding
    }
}
impl From<data_encoding::DecodeError> for KeyError {
    fn from(_: data_encoding::DecodeError) -> Self {
        KeyError::Encoding
    }
}
#[derive(Serialize, Deserialize)]
pub struct SecretKey {
    pub version: u64,
    pub algorithm: Algorithm,
    pub expires: chrono::DateTime<chrono::Utc>,
    pub encryption: Option<Encryption>,
    pub key: String,
}
pub enum SKey {
    Ed25519 {
        key: ed25519_dalek::Keypair,
        expires: chrono::DateTime<chrono::Utc>,
    },
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct PublicKey {
    pub version: u64,
    pub algorithm: Algorithm,
    pub expires: chrono::DateTime<chrono::Utc>,
    pub signature: String,
    pub key: String,
}
#[derive(Debug)]
pub enum PKey {
    Ed25519 {
        expires: chrono::DateTime<chrono::Utc>,
        signature: String,
        key: ed25519_dalek::PublicKey,
    },
}
#[test]
fn sign_public_key() {
    use chrono::Datelike;
    let expires = chrono::Utc::now();
    let expires = expires.with_year(expires.year() + 1).unwrap();
    let sk = SKey::generate(expires);
    let pk = sk.public_key();
    println!("{:?}", pk);
    let pk = pk.load().unwrap();
    println!("{:?}", pk);
}
#[derive(Debug, Serialize, Deserialize)]
pub struct Signature {
    pub version: u64,
    pub key: PublicKey,
    pub signature: String,
    pub date: chrono::DateTime<chrono::Utc>,
}
impl SKey {
    pub fn sign(&self, h: &[u8]) -> Result<Signature, KeyError> {
        Ok(Signature {
            version: VERSION,
            signature: self.sign_raw(h)?,
            key: self.public_key(),
            date: chrono::Utc::now(),
        })
    }
    pub fn sign_raw(&self, h: &[u8]) -> Result<String, KeyError> {
        match self {
            SKey::Ed25519 { key, expires } => {
                if expires <= &chrono::Utc::now() {
                    return Err(KeyError::Expired);
                }
                let mut prehashed = ed25519_dalek::Sha512::new();
                prehashed.update(h);
                let sig = key.sign_prehashed(prehashed, Some(CONTEXT)).unwrap();
                Ok(data_encoding::BASE32_NOPAD.encode(&sig.to_bytes()))
            }
        }
    }
    pub fn generate(expires: chrono::DateTime<chrono::Utc>) -> Self {
        use rand::RngCore;
        let mut key = [0; 32];
        rand::thread_rng().fill_bytes(&mut key);
        SKey::Ed25519 {
            key: ed25519_dalek::Keypair::from_bytes(&key).unwrap(),
            expires,
        }
    }
    pub fn save(&self, password: Option<&str>) -> SecretKey {
        match self {
            SKey::Ed25519 { key, expires } => {
                let mut key = key.to_bytes();
                let encryption = if let Some(password) = password {
                    use rand::Rng;
                    let salt = rand::thread_rng()
                        .sample_iter(&rand::distributions::Alphanumeric)
                        .take(32)
                        .collect();
                    let enc = Encryption::Aes128(Kdf::Pbkdf2 { salt });
                    enc.encrypt(password.as_bytes(), &mut key);
                    Some(enc)
                } else {
                    None
                };
                SecretKey {
                    version: VERSION,
                    algorithm: Algorithm::Ed25519,
                    expires: expires.clone(),
                    encryption,
                    key: data_encoding::BASE32_NOPAD.encode(&key),
                }
            }
        }
    }
    pub fn public_key(&self) -> PublicKey {
        match self {
            SKey::Ed25519 { key, expires } => {
                let to_sign =
                    bincode::serialize(&(Algorithm::Ed25519, expires.clone(), key.public)).unwrap();
                debug!("to_sign {:?}", to_sign);
                let mut prehashed = ed25519_dalek::Sha512::new();
                prehashed.update(&to_sign);
                let sig = key.sign_prehashed(prehashed, Some(CONTEXT)).unwrap();
                PublicKey {
                    version: VERSION,
                    algorithm: Algorithm::Ed25519,
                    expires: expires.clone(),
                    key: data_encoding::BASE32_NOPAD.encode(&key.public.clone().to_bytes()),
                    signature: data_encoding::BASE32_NOPAD.encode(&sig.to_bytes()),
                }
            }
        }
    }
    pub fn pkey(&self) -> PKey {
        match self {
            SKey::Ed25519 { key, expires } => {
                let to_sign =
                    bincode::serialize(&(Algorithm::Ed25519, expires.clone(), key.public)).unwrap();
                debug!("to_sign {:?}", to_sign);
                let mut prehashed = ed25519_dalek::Sha512::new();
                prehashed.update(&to_sign);
                let sig = key.sign_prehashed(prehashed, Some(CONTEXT)).unwrap();
                PKey::Ed25519 {
                    expires: expires.clone(),
                    key: key.public.clone(),
                    signature: data_encoding::BASE32_NOPAD.encode(&sig.to_bytes()),
                }
            }
        }
    }
}
impl SecretKey {
    pub fn load(&self, pw: Option<&str>) -> Result<SKey, KeyError> {
        if self.expires <= chrono::Utc::now() {
            return Err(KeyError::Expired);
        }
        match self.algorithm {
            Algorithm::Ed25519 => {
                let mut key_enc = data_encoding::BASE32_NOPAD.decode(self.key.as_bytes())?;
                if let Some(ref enc) = self.encryption {
                    let password = if let Some(ref pw) = pw {
                        pw
                    } else {
                        return Err(KeyError::NoPassword);
                    };
                    enc.decrypt(password.as_bytes(), &mut key_enc);
                }
                Ok(SKey::Ed25519 {
                    key: ed25519_dalek::Keypair::from_bytes(&key_enc)?,
                    expires: self.expires,
                })
            }
        }
    }
}
impl PublicKey {
    pub fn fingerprint(&self) -> String {
        match self.algorithm {
            Algorithm::Ed25519 => {
                let signed =
                    bincode::serialize(&(Algorithm::Ed25519, self.expires.clone(), &self.key))
                        .unwrap();
                let mut prehashed = ed25519_dalek::Sha512::new();
                prehashed.update(&signed);
                data_encoding::BASE32_NOPAD.encode(&prehashed.finalize())
            }
        }
    }
    pub fn load(&self) -> Result<PKey, KeyError> {
        match self.algorithm {
            Algorithm::Ed25519 => {
                let key = ed25519_dalek::PublicKey::from_bytes(
                    &data_encoding::BASE32_NOPAD.decode(self.key.as_bytes())?,
                )?;
                let mut signature = [0; 64];
                data_encoding::BASE32_NOPAD
                    .decode_mut(self.signature.as_bytes(), &mut signature)?;
                let signature = ed25519_dalek::Signature::new(signature);
                let signed =
                    bincode::serialize(&(Algorithm::Ed25519, self.expires.clone(), &key)).unwrap();
                debug!("signed {:?}", signed);
                key.verify_strict(&signed, &signature)?;
                Ok(PKey::Ed25519 {
                    signature: self.signature.clone(),
                    expires: self.expires.clone(),
                    key,
                })
            }
        }
    }
}
impl PKey {
    pub fn save(&self) -> PublicKey {
        match self {
            PKey::Ed25519 {
                key,
                expires,
                signature,
            } => PublicKey {
                version: VERSION,
                algorithm: Algorithm::Ed25519,
                expires: expires.clone(),
                signature: signature.clone(),
                key: data_encoding::BASE32_NOPAD.encode(key.as_bytes()),
            },
        }
    }
    pub fn verify(
        &self,
        h: &[u8],
        signature: &str,
        date: &chrono::DateTime<chrono::Utc>,
    ) -> Result<(), KeyError> {
        match self {
            PKey::Ed25519 { key, expires, .. } => {
                if expires <= date {
                    return Err(KeyError::Expired);
                }
                let mut sig = [0; 64];
                data_encoding::BASE32_NOPAD.decode_mut(signature.as_bytes(), &mut sig)?;
                let sig = ed25519_dalek::Signature::new(sig);
                let mut prehashed = ed25519_dalek::Sha512::new();
                prehashed.update(h);
                key.verify_prehashed(prehashed, Some(CONTEXT), &sig)?;
                Ok(())
            }
        }
    }
}
#[test]
fn verify_test() {
    use chrono::Datelike;
    let expires = chrono::Utc::now();
    let expires = expires.with_year(expires.year() + 1).unwrap();
    let sk = SKey::generate(expires);
    let m = b"blabla";
    let signature = sk.sign(m).unwrap();
    signature.verify(m).unwrap();
}
impl Signature {
    pub fn verify(&self, h: &[u8]) -> Result<(), KeyError> {
        self.key.load()?.verify(h, &self.signature, &self.date)
    }
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum Algorithm {
    Ed25519,
}
#[derive(Serialize, Deserialize)]
pub enum Encryption {
    Aes128(Kdf),
}
#[derive(Serialize, Deserialize)]
pub enum Kdf {
    Pbkdf2 { salt: String },
}
impl Encryption {
    pub fn encrypt<'a>(&self, password: &[u8], bytes: &'a mut [u8]) {
        match self {
            Encryption::Aes128(Kdf::Pbkdf2 { ref salt }) => {
                let mut kdf = [0; 32];
                pbkdf2::pbkdf2::<Hmac<Sha256>>(password, salt.as_ref(), 10_000, &mut kdf);
                use aes::{
                    cipher::FromBlockCipher, cipher::StreamCipher, Aes128, Aes128Ctr,
                    NewBlockCipher,
                };
                let (a, b) = kdf.split_at(16);
                let cipher = Aes128::new(generic_array::GenericArray::from_slice(&a));
                let mut cipher = Aes128Ctr::from_block_cipher(
                    cipher,
                    generic_array::GenericArray::from_slice(b),
                );
                cipher.apply_keystream(bytes);
            }
        }
    }
    pub fn decrypt<'a>(&self, password: &[u8], bytes: &'a mut [u8]) {
        self.encrypt(password, bytes)
    }
}
#[test]
fn encrypt_decrypt() {
    let enc = Encryption::Aes128(Kdf::Pbkdf2 {
        salt: "blabla".to_string(),
    });
    let b0 = b"very confidential secret".to_vec();
    let mut b = b0.clone();
    enc.encrypt(b"password", &mut b[..]);
    println!("{:?}", b);
    enc.decrypt(b"password", &mut b[..]);
    println!("{:?}", b);
    assert_eq!(b, b0);
}

    #[error(transparent)]
    Json(#[from] serde_json::Error),

    pub authors: Vec<Author>,
}
#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
pub struct Author {
    pub name: String,
    #[serde(default)]
    pub full_name: Option<String>,
    #[serde(default)]
    pub email: Option<String>,
}
impl std::fmt::Display for Author {
    fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
        if self.full_name.is_none() && self.email.is_none() {
            write!(fmt, "{:?}", self.name)
        } else {
            write!(fmt, "{{ name = {:?}", self.name)?;
            if let Some(ref f) = self.full_name {
                write!(fmt, ", full_name = {:?}", f)?;
            }
            if let Some(ref f) = self.email {
                write!(fmt, ", email = {:?}", f)?;
            }
            write!(fmt, " }}")
        }
    }

    pub authors: Vec<String>,

    pub unhashed: Option<toml::Value>,

    pub unhashed: Option<serde_json::Value>,

pub const VERSION: u64 = 4;

pub const VERSION: u64 = 5;

            let s = toml::ser::to_string(un).unwrap();

            let s = serde_json::to_string(un).unwrap();

            Some(toml::de::from_slice(&out)?)

            Some(serde_json::from_slice(&out)?)

serde_json = "1.0"

ed25519-dalek = { version = "1.0", features = [ "serde" ] }

pbkdf2 = { version = "*", default-features = false }
aes = { version = "0.7", features = [ "ctr" ] }
generic-array = "*"
hmac = "*"
sha2 = "*"
rand = "0.5"
rand_core = { version = "0.6", features = ["getrandom"] }

name = "aes"
version = "0.7.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "495ee669413bfbe9e8cace80f4d3d78e6d8c8d99579f97fb93bde351b185f2d4"
dependencies = [
 "cfg-if 1.0.0",
 "cipher",
 "cpufeatures",
 "ctr",
 "opaque-debug",
]
[[package]]

 "memchr",

 "memchr 2.4.0",

version = "0.3.7"

version = "0.3.8"

checksum = "e9ff35b701f3914bdb8fad3368d822c766ef2858b2583198e41639b936f09d3f"

checksum = "b64485778c4f16a6a5a9d335e80d449ac6c70cdd6a06d2af18a6f6f775a125b3"

 "crypto-mac",

 "crypto-mac 0.8.0",

]
[[package]]
name = "block-buffer"
version = "0.9.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4152116fd6e9dadb291ae18fc1ec3575ed6d84c29642d97890f4b4a3417297e4"
dependencies = [
 "generic-array",

 "memchr",

 "memchr 2.4.0",

version = "3.6.1"

version = "3.7.0"

checksum = "63396b8a4b9de3f4fdfb320ab6080762242f66a8ef174c49d8e19b674db4cdbe"

checksum = "9c59e7af012c713f529e7a3ee57ce9b31ddd858d4b512923602f74608b009631"

version = "1.0.67"

version = "1.0.68"

checksum = "e3c69b077ad434294d3ce9f1f6143a2a4b89a8a2d54ef813d85003a4fd1137fd"

checksum = "4a72c244c1ff497a746a7e1fb3d14bd08420ecda70c8f25c7112f2781652d787"

 "memchr",

 "memchr 2.4.0",

name = "cipher"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7ee52072ec15386f770805afd189a01c8841be8696bed250fa2f13c4c0d6dfb7"
dependencies = [
 "generic-array",
]
[[package]]

]
[[package]]
name = "cloudabi"
version = "0.0.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ddfc5b9aa5d4507acaf872de71051dfd0e309860e88966e1051e462a077aac4f"
dependencies = [
 "bitflags",

name = "cpufeatures"
version = "0.1.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ed00c67cb5d0a7d64a44f6ad2668db7e7530311dd53ea79bcd4fb022c64911c8"
dependencies = [
 "libc",
]
[[package]]

version = "0.9.4"

version = "0.9.5"

checksum = "52fb27eab85b17fbb9f6fd667089e07d6a2eb8743d02639ee7f6a7a7729c9c94"

checksum = "4ec02e091aa634e2c3ada4a392989e7c3116673ef0ac5b72232439094d73b7fd"

version = "0.8.4"

version = "0.8.5"

checksum = "4feb231f0d4d6af81aed15928e58ecf5816aa62a2393e2c82f46973e92a9a278"

checksum = "d82cfc11ce7f2c3faef78d8a684447b40d503d9681acebed6cb728d45940c4db"

 "autocfg",

name = "crypto-mac"
version = "0.11.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "25fab6889090c8133f3deb8f73ba3c65a7f456f66436fc012a1b1e272b1e103e"
dependencies = [
 "generic-array",
 "subtle",
]
[[package]]

]
[[package]]
name = "ctr"
version = "0.7.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a232f92a03f37dd7d7dd2adc67166c77e9cd88de5b019b9a9eecfaeaf7bfd481"
dependencies = [
 "cipher",

name = "ed25519"
version = "1.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8d0860415b12243916284c67a9be413e044ee6668247b99ba26d94b2bc06c8f6"
dependencies = [
 "serde",
 "signature",
]
[[package]]
name = "ed25519-dalek"
version = "1.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c762bae6dcaf24c4c84667b8579785430908723d5c889f469d76a41d59cc7a9d"
dependencies = [
 "curve25519-dalek",
 "ed25519",
 "rand 0.7.3",
 "serde",
 "serde_bytes",
 "sha2",
 "zeroize",
]
[[package]]

 "redox_syscall",

 "redox_syscall 0.2.8",

name = "funty"
version = "1.1.0"

name = "fuchsia-cprng"
version = "0.1.1"

checksum = "fed34cd105917e91daa4da6b3728c47b068749d6a62c59811f06ed2ac71d9da7"

checksum = "a06f77d526c1a601b7c4cdd98f54b5eaabffc14d5f2f0296febdc7f357c6d3ba"

version = "0.3.14"

version = "0.3.15"

checksum = "a9d5813545e459ad3ca1bff9915e9ad7f1a47dc6a91b627ce321d5863b7dd253"

checksum = "0e7e43a803dae2fa37c1f6a8fe121e1f7bf9548b4dfc0522a42f34145dadfc27"

version = "0.3.14"

version = "0.3.15"

checksum = "ce79c6a52a299137a6013061e0cf0e688fce5d7f1bc60125f520912fdb29ec25"

checksum = "e682a68b29a882df0545c143dc3646daefe80ba479bcdede94d5a703de2871e2"

version = "0.3.14"

version = "0.3.15"

checksum = "098cd1c6dda6ca01650f1a37a794245eb73181d0d4d4e955e2f3c37db7af1815"

checksum = "0402f765d8a89a26043b889b26ce3c4679d268fa6bb22cd7c6aad98340e179d1"

version = "0.3.14"

version = "0.3.15"

checksum = "10f6cb7042eda00f0049b1d2080aa4b93442997ee507eb3828e8bd7577f94c9d"

checksum = "badaa6a909fac9e7236d0620a2f57f7664640c56575b71a7552fbd68deafab79"

version = "0.3.14"

version = "0.3.15"

checksum = "365a1a1fb30ea1c03a830fdb2158f5236833ac81fa0ad12fe35b29cddc35cb04"

checksum = "acc499defb3b348f8d8f3f66415835a9131856ff7714bf10dadfc4ec4bdb29a1"

version = "0.3.14"

version = "0.3.15"

checksum = "668c6733a182cd7deb4f1de7ba3bf2120823835b3bcfbeacf7d2c4a773c1bb8b"

checksum = "a4c40298486cdf52cc00cd6d6987892ba502c7656a16a4192a9992b1ccedd121"

 "autocfg",

version = "0.3.14"

version = "0.3.15"

checksum = "5c5629433c555de3d82861a7a4e3794a4c40040390907cfbfd7143a92a426c23"

checksum = "a57bead0ceff0d6dde8f465ecd96c9338121bb7717d3e7b108059531870c4282"

version = "0.3.14"

version = "0.3.15"

checksum = "ba7aa51095076f3ba6d9a1f702f74bd05ec65f555d70d2033d55ba8d69f581bc"

checksum = "8a16bef9fc1a4dddb5bee51c989e3fbba26569cbb0e31f5b303c184e3dd33dae"

version = "0.3.14"

version = "0.3.15"

checksum = "3c144ad54d60f23927f0a6b6d816e4271278b64f005ad65e4e35291d2de9c025"

checksum = "feb5c238d27e2bf94ffdfd27b2c29e3df4a68c4193bb6427384259e2bf191967"

 "autocfg",

 "memchr",

 "memchr 2.4.0",

version = "0.2.2"

version = "0.2.3"

checksum = "c9495705279e7140bf035dde1f6e750c162df8b625267cd52cc44e0b156732c8"

checksum = "7fcd999463524c52659517fe2cea98493cfe485d10565e7b0fb07dbba7ad2753"

version = "0.13.18"

version = "0.13.20"

checksum = "b483c6c2145421099df1b4efd50e0f6205479a072199460eff852fa15e5603c7"

checksum = "d9831e983241f8c5591ed53f17d874833e2fa82cac2625f3888c50cbfe136cba"

]
[[package]]
name = "hmac"
version = "0.11.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2a2a2320eb7ec0ebe8da8f744d7812d9fc4cb4d09344ac01898dbcb6a20ae69b"
dependencies = [
 "crypto-mac 0.11.0",
 "digest",

version = "1.0.0"

version = "1.0.1"

checksum = "05842d0d43232b23ccb7060ecb0f0626922c21f30012e97b767b30afd4a5d4b9"

checksum = "6456b8a6c8f33fee7d958fcd1b60d55b11940a79e63ae87013e6d22e26034440"

version = "0.14.7"

version = "0.14.8"

checksum = "1e5f105c494081baa3bf9e200b279e27ec1623895cd504c7dbef8d0b080fcf54"

checksum = "d3f71a7eea53a3f8257a7b4795373ff886397178cd634430ea94e12d7fe4fe34"

 "memchr",

 "memchr 2.4.0",

name = "lexical-core"
version = "0.7.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6607c62aa161d23d17a9072cc5da0be67cdfc89d3afb1e8d9c842bebc2525ffe"
dependencies = [
 "arrayvec",
 "bitflags",
 "cfg-if 1.0.0",
 "ryu",
 "static_assertions",
]
[[package]]

version = "0.2.94"

version = "0.2.95"

checksum = "18794a8ad5b29321f790b55d93dfba91e125cb1a9edbd4f8e3150acc771c1a5e"

checksum = "789da6d93f1b866ffe175afc5322a4d76c038605a1c3319bb57b06967ca98a36"

version = "0.12.19+1.1.0"

version = "0.12.21+1.1.0"

checksum = "f322155d574c8b9ebe991a04f6908bb49e68a79463338d24a43d6274cb6443e6"

checksum = "86271bacd72b2b9e854c3dcfb82efd538f15f870e4c11af66900effb462f6825"

 "aes",

 "ed25519-dalek",

 "generic-array",
 "hmac",

 "pbkdf2",

 "rand 0.5.6",
 "rand_core 0.6.2",

 "serde_json",
 "sha2",

 "tree_magic_mini",

 "tree_magic",

[[package]]
name = "lock_api"
version = "0.3.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c4da24a77a3d8a6d4862d95f72e6fdb9c09a643ecdb402d754004a557f2bec75"
dependencies = [
 "scopeguard",
]

[[package]]
name = "memchr"
version = "1.0.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "148fab2e51b4f1cfc66da2a7c32981d1d3c083a803978268bb11fe4b86925e7a"
dependencies = [
 "libc",
]

version = "0.6.3"

version = "0.6.4"

checksum = "f83fb6581e8ed1f85fd45c116db8405483899489e38406156c25eb743554361d"

checksum = "59accc507f1338036a0477ef61afdae33cde60840f4dfe481319ce3ad116ddf9"

version = "6.1.2"

version = "3.2.1"

checksum = "e7413f999671bd4745a7b624bd370a569fb6bc574b23c83a3c5ed2e453f3d5e2"

checksum = "05aec50c70fd288702bcd93284a8444607f3292dbdf2a30de5ea5dcdbe72287b"

 "bitvec",
 "funty",
 "lexical-core",
 "memchr",
 "version_check",

 "memchr 1.0.2",

version = "0.2.6"

version = "0.4.0"

checksum = "090c7f9998ee0ff65aa5b723e4009f7b217707f1fb5ea551329cc4d6231fb304"

checksum = "4e0d047c1062aa51e256408c560894e5251f08925980e53cf1aa5bd00eec6512"

name = "opaque-debug"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "624a8340c38c1b80fd549087862da4ba43e08858af025b236e509b6649fc13d5"
[[package]]

version = "0.1.2"

version = "0.1.4"

checksum = "77af24da69f9d9341038eba93a073b1fdaaa1b788221b00a69bce9e762cb32de"

checksum = "28988d872ab76095a6e6ac88d99b54fd267702734fd7ffe610ca27f533ddb95a"

version = "2.2.0"

version = "2.3.0"

checksum = "7edc011af0ae98b7f88cf7e4a83b70a54a75d2b8cb013d6efd02e5956207e9eb"

checksum = "96eaebe22d9f12429b1af6a0b5dd411ccfc5cb5968710abbb8c512046be9df90"

]
[[package]]
name = "parking_lot"
version = "0.10.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d3a704eb390aafdc107b0e392f56a82b668e3a71366993b5340f5833fd62505e"
dependencies = [
 "lock_api 0.3.4",
 "parking_lot_core 0.7.2",

 "lock_api",
 "parking_lot_core",

 "lock_api 0.4.4",
 "parking_lot_core 0.8.3",
]
[[package]]
name = "parking_lot_core"
version = "0.7.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d58c7c768d4ba344e3e8d72518ac13e259d7c7ade24167003b8488e10b6740a3"
dependencies = [
 "cfg-if 0.1.10",
 "cloudabi",
 "libc",
 "redox_syscall 0.1.57",
 "smallvec",
 "winapi",

 "redox_syscall",

 "redox_syscall 0.2.8",

[[package]]
name = "pbkdf2"
version = "0.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d95f5254224e617595d2cc3cc73ff0a5eaf2637519e25f03388154e9378b6ffa"
dependencies = [
 "crypto-mac 0.11.0",
]

version = "1.0.26"

version = "1.0.27"

checksum = "a152013215dca273577e18d2bf00fa862b89b24169fb78c4c95aeb07992c9cec"

checksum = "f0d8caf72986c1a598726adc988bb5984792ef84f5ee5aa50209145ee8077038"

name = "radium"
version = "0.5.3"

name = "rand"
version = "0.5.6"

checksum = "941ba9d78d8e2f7ce474c015eea4d9c6d25b6a3327f9832ee29a4de27f91bbb8"

checksum = "c618c47cd3ebd209790115ab837de41425723956ad3ce2e6a7f09890947cacb9"
dependencies = [
 "cloudabi",
 "fuchsia-cprng",
 "libc",
 "rand_core 0.3.1",
 "winapi",
]

version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7a6fdeb83b075e8266dcc8762c22776f6877a63111121f5f8c7411e5be7eed4b"
dependencies = [
 "rand_core 0.4.2",
]
[[package]]
name = "rand_core"
version = "0.4.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9c33a3c44ca05fa6f1807d8e6743f3824e8509beca625669633be0acbdf509dc"
[[package]]
name = "rand_core"

 "getrandom 0.2.2",

 "getrandom 0.2.3",

version = "0.1.57"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "41cc0f7e4d5d4544e8861606a285bb08d3e70712ccc7d2b84d7c0ccfaf4b05ce"
[[package]]
name = "redox_syscall"

 "getrandom 0.2.2",
 "redox_syscall",

 "getrandom 0.2.3",
 "redox_syscall 0.2.8",

 "memchr",

 "memchr 2.4.0",

 "parking_lot",

 "parking_lot 0.11.1",

version = "1.2.7"

checksum = "81ad8f3bbfb988e3ce4e5e73ee50f5d5a7f99a5e6dba4123b491feebb5da94d5"

version = "1.0.125"

version = "1.0.126"

checksum = "558dc50e1a5a5fa7112ca2ce4effcb321b0300c0d4ccf0776a9f60cd89031171"

checksum = "ec7505abeacaec74ae4778d9d9328fe5a5d04253220a85c4ee022239fc996d03"

]
[[package]]
name = "serde_bytes"
version = "0.11.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "16ae07dd2f88a366f15bd0632ba725227018c69a1c8550a927324f8eb8368bb9"
dependencies = [
 "serde",

version = "1.0.125"

version = "1.0.126"

checksum = "b093b7a2bb58203b5da3056c05b4ec1fed827dcfdb37347a8841695263b3d06d"

checksum = "963a7dbc9895aeac7ac90e74f34a5d5261828f79df35cbed41e10189d3804d43"

name = "sha2"
version = "0.9.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b362ae5752fd2137731f9fa25fd4d9058af34666ca1966fb969119cc35719f12"
dependencies = [
 "block-buffer",
 "cfg-if 1.0.0",
 "cpufeatures",
 "digest",
 "opaque-debug",
]
[[package]]

name = "signature"
version = "1.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0f0242b8e50dd9accdd56170e94ca1ebd223b098eb9c83539a6e367d0f36ae68"
[[package]]

name = "tap"
version = "1.0.1"

name = "synstructure"
version = "0.12.4"

checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"

checksum = "b834f2d66f734cb897113e34aaff2f1ab4719ca946f9a7358dba8f8064148701"
dependencies = [
 "proc-macro2",
 "quote",
 "syn",
 "unicode-xid",
]

version = "0.4.33"

version = "0.4.35"

checksum = "c0bcfbd6a598361fda270d82469fff3d65089dc33e175c9a131f7b4cd395f228"

checksum = "7d779dc6aeff029314570f666ec83f19df7280bb36ef338442cfa8c604021b80"

 "redox_syscall",

 "redox_syscall 0.2.8",

version = "0.1.16"

version = "0.1.17"

checksum = "86ca8ced750734db02076f44132d802af0b33b09942331f4459dde8636fd2406"

checksum = "633c1a546cee861a1a6d0dc69ebeca693bf4296661ba7852b9d21d159e0506df"

version = "1.0.24"

version = "1.0.25"

checksum = "e0f4a65597094d4483ddaed134f409b2cb7c1beccf25201a9f73c719254fa98e"

checksum = "fa6f76457f59514c7eeb4e59d891395fab0b2fd1d40723ae737d64153392e9c6"

version = "1.0.24"

version = "1.0.25"

checksum = "7765189610d8241a44529806d6fd1f2e0a08734313a35d5b3a556f92b381f3c0"

checksum = "8a36768c0fbf1bb15eca10defa29526bda730a2376c2ab4393ccfa16fb1a318d"

version = "0.32.9"

version = "0.32.10"

checksum = "72d58952cd321b79c05e8c999b81ed6094b627157c415679fa297007a4a84da9"

checksum = "cb1b66e306cd9ab12f999ecc97a932ef56c2c91797ee190d23020a9fca942c37"

version = "0.20.4"

version = "0.20.6"

checksum = "ca573360d2c7d31df13c747663e69d7210aa732744feeeb808c8889f40934d02"

checksum = "56bed0381d0c5755086157488cb53d1fee935d00815d4d329541e72ef07e75f7"

version = "1.5.0"

version = "1.6.1"

checksum = "83f0c8e7c0addab50b663055baf787d0af7f413a46e6e7fb9559a4e4db7137a5"

checksum = "0a38d31d7831c6ed7aad00aa4c12d9375fd225a6dd77da1d25b707346319a975"

 "memchr",

 "memchr 2.4.0",

version = "1.1.0"

version = "1.2.0"

checksum = "caf7b11a536f46a809a8a9f0bb4237020f70ecbf115b842360afb127ea2fda57"

checksum = "c49e3df43841dafb86046472506755d8501c5615673955f6aa17181125d13c37"

version = "0.6.6"

version = "0.6.7"

checksum = "940a12c99365c31ea8dd9ba04ec1be183ffe4920102bb7122c2f515437601e8e"

checksum = "1caa0b0c8d94a049db56b5acf8cba99dc0623aab1b26d5b5f5e2d945846b3592"

name = "tree_magic_mini"
version = "3.0.0"

name = "tree_magic"
version = "0.2.3"

checksum = "0687683589ce7d3912e6bf52c1620d970fbed86c27e12118ca779a3780bbf888"

checksum = "b1d99367ce3e553a84738f73bd626ccca541ef90ae757fdcdc4cbe728e6cb629"

 "once_cell",

 "parking_lot 0.10.2",

version = "0.1.17"

version = "0.1.18"

checksum = "07fbfce1c8a97d547e8b5334978438d9d6ec8c20e38f56d4a4374d181493eaef"

checksum = "33717dca7ac877f497014e10d73f3acf948c342bee31b5ca7892faf94ccc6b49"

 "getrandom 0.2.2",

 "getrandom 0.2.3",

version = "0.2.12"

version = "0.2.13"

checksum = "cbdbff6266a24120518560b5dc983096efb98462e51d0d68169895b237be3e5d"

checksum = "025ce40a007e1907e58d5bc1a594def78e5573bb0b1160bc389634e8f12e4faa"

[[package]]
name = "wyz"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "85e60b0d1b5f99db2556934e21937020776a5d31520bf169e851ac44e6420214"

version = "0.3.2"

version = "0.4.0"

checksum = "0de7bff972b4f2a06c85f6d8454b09df153af7e3a4ec2aac81db1b105b684ddb"

checksum = "e262a29d0e61ccf2b6190d7050d4b237535fc76ce4c1210d9caa316f71dffa75"

dependencies = [
 "zeroize_derive",
]
[[package]]
name = "zeroize_derive"
version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a2c1e130bebaeab2f23886bf9acbaca14b092408c452543c857f66399cd6dab1"
dependencies = [
 "proc-macro2",
 "quote",
 "syn",
 "synstructure",
]

]
name = "bitvec"
version = "0.19.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8942c8d352ae1838c9dda0b0ca2ab657696ef2232a20147cf1b30ae1a9cb4321"
dependencies = [
 "funty",
 "radium",
 "tap",
 "wyz",

[[package]]