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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
pub mod blake2b256;
pub mod convert;
pub mod fs;
pub mod rand;
pub mod serde;
pub use crate::blake2b256::Blake2b256;
use blake2;
use chrono;
use blake2::{digest::FixedOutput, Digest};
use rpassword;
use rprompt;
use std::{
env,
io::{self, BufRead, Read, Write},
path::Path,
};
pub fn now() -> chrono::DateTime<chrono::offset::FixedOffset> {
let date = chrono::offset::Local::now();
date.with_timezone(&date.offset())
}
pub fn blake2b256sum(bytes: &[u8]) -> Vec<u8> {
let mut hasher = Blake2b256::new();
hasher.input(bytes);
hasher.fixed_result().to_vec()
}
pub fn blake2b256sum_file(path: &Path) -> io::Result<Vec<u8>> {
let mut hasher = Blake2b256::new();
read_file_to_digest_input(path, &mut hasher)?;
Ok(hasher.fixed_result().to_vec())
}
pub fn base64_decode<T: ?Sized + AsRef<[u8]>>(input: &T) -> Result<Vec<u8>, base64::DecodeError> {
base64::decode_config(input, base64::URL_SAFE_NO_PAD)
}
pub fn base64_encode<T: ?Sized + AsRef<[u8]>>(input: &T) -> String {
base64::encode_config(input, base64::URL_SAFE_NO_PAD)
}
pub fn read_file_to_digest_input(
path: &Path,
input: &mut impl blake2::digest::Input,
) -> io::Result<()> {
let file = std::fs::File::open(path)?;
let mut reader = io::BufReader::new(file);
loop {
let length = {
let buffer = reader.fill_buf()?;
input.input(buffer);
buffer.len()
};
if length == 0 {
break;
}
reader.consume(length);
}
Ok(())
}
pub fn yes_or_no_was_y(msg: &str) -> io::Result<bool> {
loop {
let reply = rprompt::prompt_reply_stderr(msg)?;
match reply.as_str() {
"y" | "Y" => return Ok(true),
"n" | "N" => return Ok(false),
_ => {}
}
}
}
pub fn read_passphrase() -> io::Result<String> {
if let Ok(pass) = env::var("CREV_PASSPHRASE") {
eprint!("Using passphrase set in CREV_PASSPHRASE\n");
return Ok(pass);
}
eprint!("Enter passphrase to unlock: ");
rpassword::read_password()
}
pub fn read_new_passphrase() -> io::Result<String> {
if let Ok(pass) = env::var("CREV_PASSPHRASE") {
eprint!("Using passphrase set in CREV_PASSPHRASE\n");
return Ok(pass);
}
loop {
eprint!("Enter new passphrase: ");
let p1 = rpassword::read_password()?;
eprint!("Enter new passphrase again: ");
let p2 = rpassword::read_password()?;
if p1 == p2 {
return Ok(p1);
}
eprintln!("\nPassphrases don't match, try again.");
}
}
pub fn read_file_to_string(path: &Path) -> io::Result<String> {
let mut file = std::fs::File::open(&path)?;
let mut res = String::new();
file.read_to_string(&mut res)?;
Ok(res)
}
pub fn store_str_to_file(path: &Path, s: &str) -> io::Result<()> {
std::fs::create_dir_all(path.parent().expect("Not a root path"))?;
let tmp_path = path.with_extension("tmp");
let mut file = std::fs::File::create(&tmp_path)?;
file.write_all(&s.as_bytes())?;
file.flush()?;
drop(file);
std::fs::rename(tmp_path, path)?;
Ok(())
}
pub fn store_to_file_with<E, F>(path: &Path, f: F) -> io::Result<Result<(), E>>
where
F: Fn(&mut dyn io::Write) -> Result<(), E>,
{
std::fs::create_dir_all(path.parent().expect("Not a root path"))?;
let tmp_path = path.with_extension("tmp");
let mut file = std::fs::File::create(&tmp_path)?;
if let Err(e) = f(&mut file) {
return Ok(Err(e));
}
file.flush()?;
file.sync_data()?;
drop(file);
std::fs::rename(tmp_path, path)?;
Ok(Ok(()))
}