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
|
pub async fn login(
sock: &mut crate::sock::Sock,
state: std::sync::Arc<tokio::sync::RwLock<crate::agent::State>>,
tty: Option<&str>,
) {
let mut state = state.write().await;
let email = config_email().await;
let mut db = rbw::db::Db::load_async(&email)
.await
.unwrap_or_else(|_| rbw::db::Db::new());
if db.needs_login() {
let url = config_base_url().await;
let url = reqwest::Url::parse(&url).unwrap();
let password = rbw::pinentry::getpin(
"Master Password",
&format!("Log in to {}", url.host_str().unwrap()),
tty,
)
.await
.unwrap();
let (access_token, refresh_token, iterations, protected_key, keys) =
rbw::actions::login(&email, &password).await.unwrap();
state.priv_key = Some(keys);
db.access_token = Some(access_token);
db.refresh_token = Some(refresh_token);
db.iterations = Some(iterations);
db.protected_key = Some(protected_key);
db.save_async(&email).await.unwrap();
sync(sock).await;
} else {
respond_ack(sock).await;
}
}
pub async fn unlock(
sock: &mut crate::sock::Sock,
state: std::sync::Arc<tokio::sync::RwLock<crate::agent::State>>,
tty: Option<&str>,
) {
let mut state = state.write().await;
if state.needs_unlock() {
let email = config_email().await;
let password = rbw::pinentry::getpin(
"Master Password",
"Unlock the local database",
tty,
)
.await
.unwrap();
let db = rbw::db::Db::load_async(&email)
.await
.unwrap_or_else(|_| rbw::db::Db::new());
let keys = rbw::actions::unlock(
&email,
&password,
db.iterations.unwrap(),
db.protected_key.as_deref().unwrap(),
)
.await
.unwrap();
state.priv_key = Some(keys);
}
respond_ack(sock).await;
}
pub async fn lock(
sock: &mut crate::sock::Sock,
state: std::sync::Arc<tokio::sync::RwLock<crate::agent::State>>,
) {
let mut state = state.write().await;
state.priv_key = None;
respond_ack(sock).await;
}
pub async fn sync(sock: &mut crate::sock::Sock) {
let email = config_email().await;
let mut db = rbw::db::Db::load_async(&email)
.await
.unwrap_or_else(|_| rbw::db::Db::new());
let (protected_key, ciphers) =
rbw::actions::sync(db.access_token.as_ref().unwrap())
.await
.unwrap();
db.protected_key = Some(protected_key);
db.ciphers = ciphers;
db.save_async(&email).await.unwrap();
respond_ack(sock).await;
}
pub async fn decrypt(
sock: &mut crate::sock::Sock,
state: std::sync::Arc<tokio::sync::RwLock<crate::agent::State>>,
cipherstring: &str,
) {
let state = state.read().await;
let keys = state.priv_key.as_ref().unwrap();
let cipherstring =
rbw::cipherstring::CipherString::new(cipherstring).unwrap();
let plaintext =
String::from_utf8(cipherstring.decrypt(keys).unwrap()).unwrap();
respond_decrypt(sock, plaintext).await;
}
async fn respond_ack(sock: &mut crate::sock::Sock) {
sock.send(&rbw::agent::Response::Ack).await;
}
async fn respond_decrypt(sock: &mut crate::sock::Sock, plaintext: String) {
sock.send(&rbw::agent::Response::Decrypt { plaintext })
.await;
}
async fn config_email() -> String {
let config = rbw::config::Config::load_async().await.unwrap();
config.email.unwrap()
}
async fn config_base_url() -> String {
let config = rbw::config::Config::load_async().await.unwrap();
config.base_url()
}
|
