cbradio 0.1.0

System orchestration based on Redis
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

// SPDX-FileCopyrightText: 2021 Jakub Pastuszek <jpastuszek@protonmail.com>
//
// SPDX-License-Identifier: GPL-3.0-or-later
use cotton::prelude::*;

use cbradio::crypto::{
    generate_encryption_key, generate_signing_key,
    encode,
    default_base_staion_public_key_file, default_base_staion_secret_key_file,
    default_network_public_key_file, default_network_secret_key_file,
    SignPublicKey,
};
use cbradio::with_create_dir;

#[derive(Debug, StructOpt)]
enum KeyPair {
    /// Generate base station key pair
    BaseStation,
    /// Generate network key pair
    Network,
}

/// Generate key pairs for cbradio communication
#[derive(Debug, StructOpt)]
struct Cli {
    #[structopt(flatten)]
    logging: LoggingOpt,

    /// File path where to store the public key
    #[structopt(long, short = "k")]
    public_key: Option<PathBuf>,

    /// File path where to store the secret key
    #[structopt(long, short = "K")]
    secret_key: Option<PathBuf>,

    #[structopt(subcommand)]
    key_pair: KeyPair,
}

fn write_key_pair(public_key_file: &Path, secret_key_file: &Path, generate_key_pair: impl Fn() -> ([u8; 32], [u8; 32])) -> PResult<()> {
    if public_key_file.exists() {
        problem!("Public key file already exists")?;
    }
    if secret_key_file.exists() {
        problem!("Secret key file already exists")?;
    }

    let (public_key, secret_key)  = generate_key_pair();

    write(public_key_file, encode(&public_key))?;
    println!("Written public key: {}", public_key_file.display());

    with_umask(0o077, || write(secret_key_file, encode(&secret_key)))?;
    println!("Written public key: {}", secret_key_file.display());

    Ok(())
}

fn main() -> FinalResult {
    let args = Cli::from_args();
    init_logger(&args.logging, vec![module_path!()]);

    match args.key_pair {
        KeyPair::BaseStation => {
            let public_key_file = args.public_key.map(Ok).unwrap_or_else(|| with_create_dir(default_base_staion_public_key_file()))?;
            let secret_key_file = args.secret_key.map(Ok).unwrap_or_else(|| with_create_dir(default_base_staion_secret_key_file()))?;

            write_key_pair(&public_key_file, &secret_key_file, || {
                let key = generate_signing_key();
                let pub_key: SignPublicKey = (&key).into();
                (pub_key.to_bytes(), key.to_bytes())
            })?;
        },
        KeyPair::Network => {
            let public_key_file = args.public_key.map(Ok).unwrap_or_else(|| with_create_dir(default_network_public_key_file()))?;
            let secret_key_file = args.secret_key.map(Ok).unwrap_or_else(|| with_create_dir(default_network_secret_key_file()))?;

            write_key_pair(&public_key_file, &secret_key_file, || {
                let key = generate_encryption_key();
                let pub_key = key.public_key();
                (*pub_key.as_bytes(), key.to_bytes())
            })?;
        },
    };

    Ok(())
}