tmkms 0.2.3

Tendermint Key Management System
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
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

extern crate serde_json;

use super::*;

use std::fs::File;
use std::io::prelude::*;
use std::process;
use std::str;

use abscissa::Callable;
use signatory::ed25519;
use signatory::ed25519::Seed;
use subtle_encoding::base64;
use tendermint::public_keys::ConsensusKey;
use yubihsm;

use serde_json::Value;

/// The `yubihsm keys import` subcommand
#[derive(Debug, Default, Options)]
pub struct ImportCommand {
    /// Path to configuration file
    #[options(short = "c", long = "config")]
    pub config: Option<String>,

    /// Path to the validator configuration file
    #[options(short = "p", long = "path")]
    pub path: Option<String>,

    /// Type of key to import (default 'ed25519')
    #[options(short = "t")]
    pub key_type: Option<String>,

    /// Label for imported key
    #[options(short = "l", long = "label")]
    pub label: Option<String>,

    /// Key ID for imported key
    #[options(free)]
    key_id: Option<u16>,
}

impl Callable for ImportCommand {
    fn call(&self) {
        if self.path.is_none() {
            status_err!("must provide a valid path to priv_validator.json");
            process::exit(1);
        }

        if self.key_id.is_none() {
            status_err!("must provide a unique key_id");
            process::exit(1);
        }

        match &self.key_type {
            Some(ref key_type) => if key_type != DEFAULT_KEY_TYPE {
                status_err!(
                    "only supported key type is: ed25519 (given: \"{}\")",
                    key_type
                );
                process::exit(1);
            },
            None => (),
        }

        if let Some(path) = &self.path {
            let mut f = File::open(path).unwrap_or_else(|e| {
                status_err!("couldn't open validator config file {}: {}", path, e);
                process::exit(1);
            });

            let mut contents = Vec::new();
            f.read_to_end(&mut contents).unwrap_or_else(|e| {
                status_err!("couldn't read validator config file {}: {}", path, e);
                process::exit(1);
            });
            let v: Value = serde_json::from_slice(&contents).unwrap();
            let s = v["priv_key"]["value"].as_str().unwrap_or_else(|| {
                status_err!("couldn't read validator private key from config: {}", path);
                process::exit(1);
            });

            let key_pair = base64::decode(s).unwrap_or_else(|e| {
                status_err!("couldn't decode validator private key from config: {}", e);
                process::exit(1);
            });
            let seed = Seed::from_keypair(&key_pair).unwrap_or_else(|e| {
                status_err!("invalid key in validator config: {}", e);
                process::exit(1);
            });
            let key = seed.as_secret_slice();
            let label =
                yubihsm::ObjectLabel::from(self.label.as_ref().map(|l| l.as_ref()).unwrap_or(""));

            let mut hsm = yubihsm::get_hsm_client();

            if let Err(e) = hsm.put_asymmetric_key(
                self.key_id.unwrap(),
                label,
                DEFAULT_DOMAINS,
                DEFAULT_CAPABILITIES,
                yubihsm::AsymmetricAlg::Ed25519,
                key,
            ) {
                status_err!("couldn't import key #{}: {}", self.key_id.unwrap(), e);
                process::exit(1);
            }

            let public_key = ed25519::PublicKey::from_bytes(
                hsm.get_pubkey(self.key_id.unwrap()).unwrap_or_else(|e| {
                    status_err!(
                        "couldn't get public key for key #{}: {}",
                        self.key_id.unwrap(),
                        e
                    );
                    process::exit(1);
                }),
            ).unwrap();

            status_ok!(
                "Imported",
                "key #{}: {}",
                self.key_id.unwrap(),
                ConsensusKey::from(public_key)
            );
        }
    }
}

impl_command!(ImportCommand);