Merge branch 'main' of github.com:betrusted-io/xous-core

This commit is contained in:
Sean Cross 2022-06-24 15:55:24 +08:00
commit 66d7cfe1ca
12 changed files with 1050 additions and 172 deletions

26
Cargo.lock generated
View file

@ -154,6 +154,12 @@ version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "349a06037c7bf932dd7e7d1f653678b2038b9ad46a74102f1fc7bd7872678cce"
[[package]]
name = "base32"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "23ce669cd6c8588f79e15cf450314f9638f967fc5770ff1c7c1deb0925ea7cfa"
[[package]]
name = "base64"
version = "0.13.0"
@ -3095,6 +3101,19 @@ dependencies = [
"syn",
]
[[package]]
name = "sha-1"
version = "0.9.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "99cd6713db3cf16b6c84e06321e049a9b9f699826e16096d23bbcc44d15d51a6"
dependencies = [
"block-buffer 0.9.0",
"cfg-if 1.0.0",
"cpufeatures",
"digest 0.9.0",
"opaque-debug",
]
[[package]]
name = "sha2"
version = "0.9.8"
@ -3890,15 +3909,19 @@ name = "vault"
version = "0.1.0"
dependencies = [
"arrayref",
"base32",
"byteorder",
"cbor",
"chrono",
"content-plugin-api",
"crypto-mac",
"ctap-crypto",
"digest 0.9.0",
"enum-iterator",
"gam",
"graphics-server",
"hex 0.4.3",
"hmac 0.11.0",
"ime-plugin-api",
"locales",
"log",
@ -3909,7 +3932,10 @@ dependencies = [
"passwords",
"pddb",
"rand_core 0.6.3",
"random-pick",
"rkyv",
"sha-1",
"sha2",
"subtle",
"ticktimer-server",
"trng",

View file

@ -171,7 +171,7 @@ perform the Xous firmware upgrade. This requires running manual update commands,
- Autobacklight feature: selectable feature to automatically raise the backlight when keys are pressed. Thanks to gsora for the feature!
- More importantly, this adds `crossbeam` into the kernel. This is a somewhat heavyweight item and is not recommended for use in core
services, but by including it to drive the auto-backlight feature, we get regular code coverage of the condvar pathway.
- TOTP integration thanks to blakesmith's PoC TOTP code!
## Roadmap to 1.0

View file

@ -39,6 +39,16 @@ chrono = {version = "0.4.19", default-features = false, features = ["std"]}
# password generation
passwords = "3.1.9"
# totp
crypto-mac = "0.11.1"
sha-1 = "0.9.8"
hmac = "0.11.0"
digest = "0.9.0"
base32 = "0.4.0"
sha2 = {path="../../services/engine-sha512"}
# testing
random-pick = {version = "1.2.15", optional = true}
[dev-dependencies]
enum-iterator = "0.6.0"
@ -48,4 +58,5 @@ with_ctap1 = ["ctap-crypto/with_ctap1"]
with_ctap2_1 = []
autotest = []
multireset = [] # allows credential reset more than once per boot
default = ["with_ctap1", "with_ctap2_1"]
default = ["with_ctap1", "with_ctap2_1", "testing"]
testing = ["random-pick"]

View file

@ -47,6 +47,12 @@
"zh": "无法编辑 FIDO2 令牌。",
"en-tts": "Can't edit FIDO2 tokens."
},
"vault.error.add_fido2": {
"en": "FIDO tokens are added through the web.",
"ja": "FIDOトークンはWebを使用して追加されます.",
"zh": "FIDO 令牌是使用网络添加的.",
"en-tts": "FIDO tokens are added through the web."
},
"vault.error.internal_error": {
"en": "Internal error.",
"ja": "内部エラー.",
@ -83,6 +89,12 @@
"zh": "取消",
"en-tts": "No"
},
"vault.newitem.totp_ss": {
"en": "Enter the TOTP shared secret in Base32:",
"ja": "Base32にTOTP共有シークレットを入力します。",
"zh": "在 Base32 中输入 TOTP 共享密钥:",
"en-tts": "Enter the TOTP shared secret in Base32:"
},
"vault.newitem.name": {
"en": "Please name the credential:",
"ja": "クレデンシャルに名前を付ける:",
@ -149,6 +161,12 @@
"zh": "请输入 1-128 之间的数字",
"en-tts": "Please enter a number from 1-128"
},
"vault.illegal_totp": {
"en": "Shared secret is not valid Base32",
"ja": "共有秘密は無効ですBase32",
"zh": "共享密钥无效 Base32",
"en-tts": "Shared secret is not valid Base32"
},
"vault.no_items": {
"en": "No items found",
"ja": "項目は見つかりませんでした",

View file

@ -1,3 +1,4 @@
use core::convert::TryFrom;
use std::thread;
use gam::TextEntryPayload;
use std::sync::{Arc, Mutex, atomic::{AtomicBool, Ordering}};
@ -11,13 +12,19 @@ use chrono::{Utc, DateTime, NaiveDateTime};
use std::time::{SystemTime, UNIX_EPOCH};
use std::cell::RefCell;
use crate::ux::ListItem;
use crate::{ux::{ListItem, deserialize_app_info}, ctap::FIDO_CRED_DICT};
use crate::{VaultMode, SelectedEntry};
use crate::fido::U2F_APP_DICT;
use crate::totp::TotpAlgorithm;
pub(crate) const VAULT_PASSWORD_DICT: &'static str = "vault.passwords";
pub(crate) const VAULT_TOTP_DICT: &'static str = "vault.totp";
/// bytes to reserve for a key entry. Making this slightly larger saves on some churn as stuff gets updated
pub(crate) const VAULT_ALLOC_HINT: usize = 256;
pub(crate) const VAULT_TOTP_ALLOC_HINT: usize = 128;
const VAULT_PASSWORD_REC_VERSION: u32 = 1;
const VAULT_TOTP_REC_VERSION: u32 = 1;
/// time allowed between dialog box swaps for background operations to redraw
const SWAP_DELAY_MS: usize = 300;
@ -32,6 +39,18 @@ pub(crate) struct PasswordRecord {
pub count: u64,
}
pub(crate) struct TotpRecord {
pub version: u32,
// as base32, RFC4648 no padding
pub secret: String,
pub name: String,
pub algorithm: TotpAlgorithm,
pub notes: String,
pub digits: u32,
pub timestep: u64,
pub ctime: u64,
}
#[derive(Debug, num_derive::FromPrimitive, num_derive::ToPrimitive)]
pub(crate) enum ActionOp {
/// Menu items
@ -42,6 +61,9 @@ pub(crate) enum ActionOp {
/// Internal ops
UpdateMode,
Quit,
#[cfg(feature="testing")]
/// Testing
GenerateTests,
}
pub(crate) fn start_actions_thread(
@ -96,6 +118,11 @@ pub(crate) fn start_actions_thread(
None => {
log::error!("msg could not be decoded {:?}", msg);
}
#[cfg(feature="testing")]
Some(ActionOp::GenerateTests) => {
manager.populate_tests();
manager.retrieve_db();
}
}
}
xous::destroy_server(sid).ok();
@ -296,7 +323,7 @@ impl ActionManager {
};
let ser = serialize_password(&record);
let guid = self.gen_guid();
log::info!("storing into guid: {}", guid);
log::debug!("storing into guid: {}", guid);
match self.pddb.borrow().get(
VAULT_PASSWORD_DICT,
&guid,
@ -306,23 +333,87 @@ impl ActionManager {
Ok(mut data) => {
match data.write(&ser) {
Ok(len) => log::debug!("wrote {} bytes", len),
Err(e) => {
self.modals.show_notification(&format!("{}\n{:?}",
t!("vault.error.internal_error", xous::LANG), e
), None).ok();
}
Err(e) => self.report_err(t!("vault.error.internal_error", xous::LANG), Some(e)),
}
}
Err(e) => {
self.modals.show_notification(&format!("{}\n{:?}",
t!("vault.error.internal_error", xous::LANG), e
), None).ok();
}
Err(e) => self.report_err(t!("vault.error.internal_error", xous::LANG), Some(e)),
}
log::info!("syncing...");
log::debug!("syncing...");
self.pddb.borrow().sync().ok();
}
VaultMode::Fido => {
self.report_err(t!("vault.error.add_fido2", xous::LANG), None::<std::io::Error>);
}
VaultMode::Totp => {
let description = match self.modals
.alert_builder(t!("vault.newitem.name", xous::LANG))
.field(None, Some(name_validator))
.build()
{
Ok(text) => {
text.content()[0].content.as_str().unwrap_or("UTF-8 error").to_string()
},
_ => {log::error!("Name entry failed"); self.action_active.store(false, Ordering::SeqCst); return}
};
self.tt.sleep_ms(SWAP_DELAY_MS).unwrap();
let secret = match self.modals
.alert_builder(t!("vault.newitem.totp_ss", xous::LANG))
.field(None, Some(totp_ss_validator))
.build()
{
Ok(text) => {
text.content()[0].content.as_str().unwrap_or("UTF-8 error").to_string()
},
_ => {log::error!("TOTP ss entry failed"); self.action_active.store(false, Ordering::SeqCst); return}
};
self.tt.sleep_ms(SWAP_DELAY_MS).unwrap();
let ss = secret.to_uppercase();
let ss_vec = if let Some(ss) = base32::decode(base32::Alphabet::RFC4648 { padding: false }, &ss) {
ss
} else {
if let Some(ss) = base32::decode(base32::Alphabet::RFC4648 { padding: true }, &ss) {
ss
} else {
if let Some(ss) = base32::decode(base32::Alphabet::Crockford, &ss) {
ss
} else {
log::error!("Shouldn't have happened: validated shared secret didn't decode!");
Vec::new()
}
}
};
let validated_secret = base32::encode(base32::Alphabet::RFC4648 { padding: false }, &ss_vec);
// time, hash, etc. are all the "expected defaults" -- if you want to change them, edit the record after entering it.
let totp = TotpRecord {
version: VAULT_TOTP_REC_VERSION,
name: description,
secret: validated_secret,
algorithm: TotpAlgorithm::HmacSha1,
digits: 6,
timestep: 30,
ctime: utc_now().timestamp() as u64,
notes: t!("vault.notes", xous::LANG).to_string(),
};
let ser = serialize_totp(&totp);
let guid = self.gen_guid();
log::debug!("storing into guid: {}", guid);
match self.pddb.borrow().get(
VAULT_TOTP_DICT,
&guid,
None, true, true,
Some(VAULT_TOTP_ALLOC_HINT), Some(crate::basis_change)
) {
Ok(mut data) => {
match data.write(&ser) {
Ok(len) => log::debug!("wrote {} bytes", len),
Err(e) => self.report_err(t!("vault.error.internal_error", xous::LANG), Some(e)),
}
}
Err(e) => self.report_err(t!("vault.error.internal_error", xous::LANG), Some(e)),
}
log::debug!("syncing...");
self.pddb.borrow().sync().ok();
}
_ => {} // not valid for these other modes
}
}
@ -331,7 +422,7 @@ impl ActionManager {
let dict = match entry.mode {
VaultMode::Password => VAULT_PASSWORD_DICT,
VaultMode::Fido => crate::fido::U2F_APP_DICT,
VaultMode::Totp => unimplemented!(),
VaultMode::Totp => VAULT_TOTP_DICT,
};
match self.pddb.borrow().delete_key(dict, entry.key_name.as_str().unwrap_or("UTF8-error"), None) {
Ok(_) => {
@ -355,14 +446,9 @@ impl ActionManager {
_ => {}
}
}
self.modals.show_notification(t!("vault.error.not_found", xous::LANG), None).ok();
}
_ => {
self.modals.show_notification(&format!("{}\n{:?}",
t!("vault.error.internal_error", xous::LANG),
e
), None).ok();
self.report_err(t!("vault.error.not_found", xous::LANG), None::<std::io::Error>);
}
_ => self.report_err(t!("vault.error.internal_error", xous::LANG), Some(e)),
}
}
}
@ -399,49 +485,23 @@ impl ActionManager {
pw.notes = edit_data.content()[3].content.as_str().unwrap().to_string();
pw.atime = utc_now().timestamp() as u64;
Some(pw)
} else {
log::error!("couldn't deserialize {}", entry.key_name);
self.modals.show_notification(t!("vault.error.record_error", xous::LANG), None).ok();
None
}
}
Err(e) => {
log::error!("couldn't access key {}: {:?}", entry.key_name, e);
self.modals.show_notification(&format!("{}\n{:?}",
t!("vault.error.internal_error", xous::LANG), e),
None
).ok();
None
} else { self.report_err(t!("vault.error.record_error", xous::LANG), None::<std::io::Error>); None }
}
Err(e) => { self.report_err(t!("vault.error.internal_error", xous::LANG), Some(e)); None }
};
maybe_update
}
Err(e) => {
match e.kind() {
std::io::ErrorKind::NotFound => {
self.modals.show_notification(t!("vault.error.not_found", xous::LANG), None).ok();
}
_ => {
self.modals.show_notification(&format!("{}\n{:?}",
t!("vault.error.internal_error", xous::LANG),
e
), None).ok();
}
std::io::ErrorKind::NotFound => self.report_err(t!("vault.error.not_found", xous::LANG), None::<std::io::Error>),
_ => self.report_err(t!("vault.error.internal_error", xous::LANG), Some(e)),
}
None
}
};
if let Some(update) = maybe_update {
match self.pddb.borrow().delete_key(dict, entry.key_name.as_str().unwrap(), None) {
Ok(_) => {}
Err(e) => {
self.modals.show_notification(&format!("{}\n{:?}",
t!("vault.error.internal_error", xous::LANG),
e
), None).ok();
return;
}
}
self.pddb.borrow().delete_key(dict, entry.key_name.as_str().unwrap(), None)
.unwrap_or_else(|e| self.report_err(t!("vault.error.internal_error", xous::LANG), Some(e)));
match self.pddb.borrow().get(
dict, entry.key_name.as_str().unwrap(), None,
false, true, Some(VAULT_ALLOC_HINT),
@ -449,21 +509,11 @@ impl ActionManager {
) {
Ok(mut record) => {
let ser = serialize_password(&update);
match record.write(&ser) {
Ok(_) => {}
Err(e) => {
self.modals.show_notification(&format!("{}\n{:?}",
t!("vault.error.internal_error", xous::LANG), e
), None).ok();
}
}
}
Err(e) => {
self.modals.show_notification(&format!("{}\n{:?}",
t!("vault.error.internal_error", xous::LANG), e
), None).ok();
return;
record.write(&ser)
.unwrap_or_else(|e| {
self.report_err(t!("vault.error.internal_error", xous::LANG), Some(e)); 0});
}
Err(e) => self.report_err(t!("vault.error.internal_error", xous::LANG), Some(e)),
}
}
self.pddb.borrow().sync().ok();
@ -490,51 +540,23 @@ impl ActionManager {
ai.notes = edit_data.content()[1].content.as_str().unwrap().to_string();
ai.atime = utc_now().timestamp() as u64;
Some(ai)
} else {
log::error!("couldn't deserialize {}", entry.key_name);
self.modals.show_notification(t!("vault.error.record_error", xous::LANG), None).ok();
None
}
}
Err(e) => {
log::error!("couldn't access key {}: {:?}", entry.key_name, e);
self.modals.show_notification(&format!("{}\n{:?}",
t!("vault.error.internal_error", xous::LANG), e),
None
).ok();
None
} else { self.report_err(t!("vault.error.record_error", xous::LANG), None::<std::io::Error>); None }
}
Err(e) => { self.report_err(t!("vault.error.internal_error", xous::LANG), Some(e)); None }
};
maybe_update
}
Err(e) => {
match e.kind() {
std::io::ErrorKind::NotFound => {
// most likely this is due to this being a FIDO2 token, which we can't edit
// there are no editable fields -- if we change them, it can break the authentication protocol.
self.modals.show_notification(t!("vault.error.fido2", xous::LANG), None).ok();
}
_ => {
self.modals.show_notification(&format!("{}\n{:?}",
t!("vault.error.internal_error", xous::LANG),
e
), None).ok();
}
std::io::ErrorKind::NotFound => self.report_err(t!("vault.error.not_found", xous::LANG), None::<std::io::Error>),
_ => self.report_err(t!("vault.error.internal_error", xous::LANG), Some(e)),
}
None
}
};
if let Some(update) = maybe_update {
match self.pddb.borrow().delete_key(dict, entry.key_name.as_str().unwrap(), None) {
Ok(_) => {}
Err(e) => {
self.modals.show_notification(&format!("{}\n{:?}",
t!("vault.error.internal_error", xous::LANG),
e
), None).ok();
return;
}
}
self.pddb.borrow().delete_key(dict, entry.key_name.as_str().unwrap(), None)
.unwrap_or_else(|e| self.report_err(t!("vault.error.internal_error", xous::LANG), Some(e)));
match self.pddb.borrow().get(
dict, entry.key_name.as_str().unwrap(), None,
false, true, Some(VAULT_ALLOC_HINT),
@ -542,27 +564,78 @@ impl ActionManager {
) {
Ok(mut record) => {
let ser = crate::fido::serialize_app_info(&update);
match record.write(&ser) {
Ok(_) => {}
Err(e) => {
self.modals.show_notification(&format!("{}\n{:?}",
t!("vault.error.internal_error", xous::LANG), e
), None).ok();
}
}
}
Err(e) => {
self.modals.show_notification(&format!("{}\n{:?}",
t!("vault.error.internal_error", xous::LANG), e
), None).ok();
return;
record.write(&ser).unwrap_or_else(|e| {
self.report_err(t!("vault.error.internal_error", xous::LANG), Some(e)); 0});
}
Err(e) => self.report_err(t!("vault.error.internal_error", xous::LANG), Some(e)),
}
}
self.pddb.borrow().sync().ok();
}
VaultMode::Totp => {
unimplemented!()
let maybe_update = match self.pddb.borrow().get(
dict, entry.key_name.as_str().unwrap(), None,
false, false, None, Some(crate::basis_change)
) {
Ok(mut record) => {
let mut data = Vec::<u8>::new();
let maybe_update = match record.read_to_end(&mut data) {
Ok(_len) => {
if let Some(mut pw) = deserialize_totp(data) {
let alg: String = pw.algorithm.into();
let edit_data = self.modals
.alert_builder(t!("vault.edit_dialog", xous::LANG))
.field(Some(pw.name), Some(name_validator))
.field(Some(pw.secret), Some(name_validator))
.field(Some(pw.notes), Some(name_validator))
.field(Some(pw.timestep.to_string()), Some(name_validator))
.field(Some(alg), Some(name_validator))
.field(Some(pw.digits.to_string()), Some(name_validator))
.build().expect("modals error in edit");
pw.name = edit_data.content()[0].content.as_str().unwrap().to_string();
pw.secret = edit_data.content()[1].content.as_str().unwrap().to_string();
pw.notes = edit_data.content()[2].content.as_str().unwrap().to_string();
if let Ok(t) = u64::from_str_radix(edit_data.content()[3].content.as_str().unwrap(), 10) {
pw.timestep = t;
}
if let Ok(alg) = TotpAlgorithm::try_from(edit_data.content()[4].content.as_str().unwrap()) {
pw.algorithm = alg;
}
if let Ok(d) = u32::from_str_radix(edit_data.content()[5].content.as_str().unwrap(), 10) {
pw.digits = d;
}
Some(pw)
} else { self.report_err(t!("vault.error.record_error", xous::LANG), None::<std::io::Error>); None }
}
Err(e) => { self.report_err(t!("vault.error.internal_error", xous::LANG), Some(e)); None }
};
maybe_update
}
Err(e) => {
match e.kind() {
std::io::ErrorKind::NotFound => self.report_err(t!("vault.error.not_found", xous::LANG), None::<std::io::Error>),
_ => self.report_err(t!("vault.error.internal_error", xous::LANG), Some(e)),
}
None
}
};
if let Some(update) = maybe_update {
self.pddb.borrow().delete_key(dict, entry.key_name.as_str().unwrap(), None)
.unwrap_or_else(|e| self.report_err(t!("vault.error.internal_error", xous::LANG), Some(e)));
match self.pddb.borrow().get(
dict, entry.key_name.as_str().unwrap(), None,
false, true, Some(VAULT_ALLOC_HINT),
Some(crate::basis_change)
) {
Ok(mut record) => {
let ser = serialize_totp(&update);
record.write(&ser).unwrap_or_else(|e| {
self.report_err(t!("vault.error.internal_error", xous::LANG), Some(e)); 0});
}
Err(e) => self.report_err(t!("vault.error.internal_error", xous::LANG), Some(e)),
}
}
self.pddb.borrow().sync().ok();
}
}
}
@ -605,7 +678,12 @@ impl ActionManager {
let keylist = match self.pddb.borrow().list_keys(VAULT_PASSWORD_DICT, None) {
Ok(keylist) => keylist,
Err(e) => {
log::error!("error accessing password database: {:?}", e);
match e.kind() {
std::io::ErrorKind::NotFound => {
log::debug!("Password dictionary not yet created");
}
_ => self.report_err("Dictionary error accessing password database", Some(e)),
}
Vec::new()
}
};
@ -627,7 +705,7 @@ impl ActionManager {
t!("vault.u2f.appinfo.authcount", xous::LANG),
pw.count,
);
let desc = format!("{} @ {}", pw.username, pw.description);
let desc = format!("{}/{}", pw.description, pw.username);
let li = ListItem {
name: desc,
extra,
@ -636,50 +714,427 @@ impl ActionManager {
};
il.push(li);
} else {
log::error!("couldn't deserialize {}", key);
self.report_err("Couldn't deserialize password:", Some(key));
}
}
Err(e) => log::error!("couldn't access key {}: {:?}", key, e),
Err(e) => self.report_err("Couldn't access password key", Some(e)),
}
}
Err(e) => log::error!("couldn't access key {}: {:?}", key, e),
Err(e) => self.report_err("Couldn't access password key", Some(e)),
}
}
}
VaultMode::Fido => {
il.push(ListItem { name: "test.com".to_string(), extra: "Used 5 mins ago".to_string(), dirty: true, guid: self.gen_guid() });
il.push(ListItem { name: "google.com".to_string(), extra: "Never used".to_string(), dirty: true, guid: self.gen_guid() });
il.push(ListItem { name: "my app".to_string(), extra: "Used 2 hours ago".to_string(), dirty: true, guid: self.gen_guid() });
il.push(ListItem { name: "💎🙌".to_string(), extra: "Used 2 days ago".to_string(), dirty: true, guid: self.gen_guid() });
il.push(ListItem { name: "百度".to_string(), extra: "Used 1 month ago".to_string(), dirty: true, guid: self.gen_guid() });
il.push(ListItem { name: "duplicate.com".to_string(), extra: "Used 1 week ago".to_string(), dirty: true, guid: self.gen_guid() });
il.push(ListItem { name: "duplicate.com".to_string(), extra: "Used 8 mins ago".to_string(), dirty: true, guid: self.gen_guid() });
il.push(ListItem { name: "amawhat.com".to_string(), extra: "Used 6 days ago".to_string(), dirty: true, guid: self.gen_guid() });
il.push(ListItem { name: "amazon.com".to_string(), extra: "Used 3 days ago".to_string(), dirty: true, guid: self.gen_guid() });
il.push(ListItem { name: "amazingcode.org".to_string(), extra: "Never used".to_string(), dirty: true, guid: self.gen_guid() });
il.push(ListItem { name: "ziggyziggyziggylongdomain.com".to_string(), extra: "Never used".to_string(), dirty: true, guid: self.gen_guid() });
il.push(ListItem { name: "another long domain name.com".to_string(), extra: "Used 2 months ago".to_string(), dirty: true, guid: self.gen_guid() });
il.push(ListItem { name: "bunniestudios.com".to_string(), extra: "Used 30 mins ago".to_string(), dirty: true, guid: self.gen_guid() });
il.push(ListItem { name: "github.com".to_string(), extra: "Used 6 hours ago".to_string(), dirty: true, guid: self.gen_guid() });
// first assemble U2F records
let keylist = match self.pddb.borrow().list_keys(U2F_APP_DICT, None) {
Ok(keylist) => keylist,
Err(e) => {
match e.kind() {
std::io::ErrorKind::NotFound => {
log::debug!("U2F dictionary not yet created");
}
_ => self.report_err("Dictionary error accessing U2F database", Some(e)),
}
Vec::new()
}
};
for key in keylist {
match self.pddb.borrow().get(
U2F_APP_DICT,
&key,
None,
false, false, None,
Some(crate::basis_change)
) {
Ok(mut record) => {
let mut data = Vec::<u8>::new();
match record.read_to_end(&mut data) {
Ok(_len) => {
if let Some(ai) = deserialize_app_info(data) {
let extra = format!("{}; {}{}",
crate::ux::atime_to_str(ai.atime),
t!("vault.u2f.appinfo.authcount", xous::LANG),
ai.count,
);
let desc = format!("{}", ai.name);
let li = ListItem {
name: desc,
extra,
dirty: true,
guid: key,
};
il.push(li);
} else {
self.report_err("Couldn't deserialize U2F:", Some(key));
}
}
Err(e) => self.report_err("Couldn't access U2F key", Some(e)),
}
}
Err(e) => self.report_err("Couldn't access U2F key", Some(e)),
}
}
let keylist = match self.pddb.borrow().list_keys(FIDO_CRED_DICT, None) {
Ok(keylist) => keylist,
Err(e) => {
match e.kind() {
std::io::ErrorKind::NotFound => {
log::debug!("FIDO2 dictionary not yet created");
}
_ => self.report_err("Dictionary error accessing FIDO2 database", Some(e)),
}
Vec::new()
}
};
// now merge in the FIDO2 records
for key in keylist {
match self.pddb.borrow().get(
FIDO_CRED_DICT,
&key,
None,
false, false, None,
Some(crate::basis_change)
) {
Ok(mut record) => {
let mut data = Vec::<u8>::new();
match record.read_to_end(&mut data) {
Ok(_len) => {
match crate::ctap::storage::deserialize_credential(&data) {
Some(result) => {
let name = if let Some(display_name) = result.user_display_name {
display_name
} else {
String::from_utf8(result.user_handle).unwrap_or("".to_string())
};
let desc = format!("{} / {}", result.rp_id, String::from_utf8(result.credential_id).unwrap_or("---".to_string()));
let extra = format!("FIDO2 {}", name);
let li = ListItem {
name: desc,
extra,
dirty: true,
guid: key,
};
il.push(li);
}
None => self.report_err("Couldn't deserialize FIDO2:", Some(key)),
}
}
Err(e) => self.report_err("Couldn't access FIDO2 key", Some(e)),
}
}
Err(e) => self.report_err("Couldn't access FIDO2 key", Some(e)),
}
}
}
VaultMode::Totp => {
il.push(ListItem { name: "gmail.com".to_string(), extra: "162 321".to_string(), dirty: true, guid: self.gen_guid() });
il.push(ListItem { name: "google.com".to_string(), extra: "445 768".to_string(), dirty: true, guid: self.gen_guid() });
il.push(ListItem { name: "my 图片 app".to_string(), extra: "982 111".to_string(), dirty: true, guid: self.gen_guid() });
il.push(ListItem { name: "🍕🍔🍟🌭".to_string(), extra: "056 182".to_string(), dirty: true, guid: self.gen_guid() });
il.push(ListItem { name: "百度".to_string(), extra: "111 111".to_string(), dirty: true, guid: self.gen_guid() });
il.push(ListItem { name: "duplicate.com".to_string(), extra: "462 124".to_string(), dirty: true, guid: self.gen_guid() });
il.push(ListItem { name: "duplicate.com".to_string(), extra: "462 124".to_string(), dirty: true, guid: self.gen_guid() });
il.push(ListItem { name: "amazon.com".to_string(), extra: "842 012".to_string(), dirty: true, guid: self.gen_guid() });
il.push(ListItem { name: "ziggyziggyziggylongdomain.com".to_string(), extra: "462 212".to_string(), dirty: true, guid: self.gen_guid() });
il.push(ListItem { name: "github.com".to_string(), extra: "Used 6 hours ago".to_string(), dirty: true, guid: self.gen_guid() });
let keylist = match self.pddb.borrow().list_keys(VAULT_TOTP_DICT, None) {
Ok(keylist) => keylist,
Err(e) => {
match e.kind() {
std::io::ErrorKind::NotFound => {
log::debug!("TOTP dictionary not yet created");
}
_ => self.report_err("Dictionary error accessing TOTP database", Some(e)),
}
Vec::new()
}
};
for key in keylist {
match self.pddb.borrow().get(
VAULT_TOTP_DICT,
&key,
None,
false, false, None,
Some(crate::basis_change)
) {
Ok(mut record) => {
let mut data = Vec::<u8>::new();
match record.read_to_end(&mut data) {
Ok(_len) => {
if let Some(totp) = deserialize_totp(data) {
let alg: String = totp.algorithm.into();
let extra = format!("{}:{}:{}:{}", totp.secret, totp.digits, totp.timestep, alg);
let desc = format!("{}", totp.name);
let li = ListItem {
name: desc,
extra,
dirty: true,
guid: key,
};
il.push(li);
} else {
self.report_err("Couldn't deserialize TOTP:", Some(key));
}
}
Err(e) => self.report_err("Couldn't access TOTP key", Some(e)),
}
}
Err(e) => self.report_err("Couldn't access TOTP key", Some(e)),
}
}
}
}
il.sort();
}
#[cfg(feature="testing")]
pub(crate) fn populate_tests(&mut self) {
use crate::ux::serialize_app_info;
let words = [
"bunnie", "foo", "turtle.net", "Fox.ng", "Bear", "dog food", "Cat.com", "FUzzy", "1off", "www_test_site_com/long_name/stupid/foo.htm",
"._weird~yy%\":'test", "//WHYwhyWHY", "Xyz|zy", "foo:bar", "f🍕🍔🍟🌭d", "💎🙌", "some ノート", "笔录4u", "@u", "sane text", "Käsesoßenrührlöffel"];
let weights = [1; 21];
const TARGET_ENTRIES: usize = 35;
const TARGET_ENTRIES_PW: usize = 300;
// for each database, populate up to TARGET_ENTRIES
// as this is testing code, it's written a bit more fragile in terms of error handling (fail-panic, rather than fail-dialog)
// --- passwords ---
let pws = self.pddb.borrow().list_keys(VAULT_PASSWORD_DICT, None).unwrap_or(Vec::new());
if pws.len() < TARGET_ENTRIES_PW {
let extra_count = TARGET_ENTRIES - pws.len();
for _ in 0..extra_count {
let desc = random_pick::pick_multiple_from_slice(&words, &weights, 3);
let description = format!("{} {} {}", desc[0], desc[1], desc[2]);
let username = random_pick::pick_from_slice(&words, &weights).unwrap().to_string();
let notes = random_pick::pick_from_slice(&words, &weights).unwrap().to_string();
let pg = PasswordGenerator {
length: 20,
numbers: true,
lowercase_letters: true,
uppercase_letters: true,
symbols: true,
spaces: false,
exclude_similar_characters: true,
strict: true,
};
let password = pg.generate_one().unwrap();
let record = PasswordRecord {
version: VAULT_PASSWORD_REC_VERSION,
description,
username,
password,
notes,
ctime: utc_now().timestamp() as u64,
atime: 0,
count: 0,
};
let ser = serialize_password(&record);
let guid = self.gen_guid();
match self.pddb.borrow().get(
VAULT_PASSWORD_DICT,
&guid,
None, true, true,
Some(VAULT_ALLOC_HINT), Some(crate::basis_change)
) {
Ok(mut data) => {
match data.write(&ser) {
Ok(len) => log::debug!("wrote {} bytes", len),
Err(e) => {
self.modals.show_notification(&format!("{}\n{:?}",
t!("vault.error.internal_error", xous::LANG), e
), None).ok();
}
}
}
Err(e) => {
self.modals.show_notification(&format!("{}\n{:?}",
t!("vault.error.internal_error", xous::LANG), e
), None).ok();
}
}
}
}
// --- U2F + FIDO ---
let fido = self.pddb.borrow().list_keys(FIDO_CRED_DICT, None).unwrap_or(Vec::new());
let u2f = self.pddb.borrow().list_keys(U2F_APP_DICT, None).unwrap_or(Vec::new());
let total = fido.len() + u2f.len();
if total < TARGET_ENTRIES {
let extra_u2f = (TARGET_ENTRIES - total) / 2;
let extra_fido = TARGET_ENTRIES - extra_u2f;
for _ in 0..extra_u2f {
let n = random_pick::pick_multiple_from_slice(&words, &weights, 2);
let name = format!("{} {}", n[0], n[1]);
let notes = random_pick::pick_from_slice(&words, &weights).unwrap().to_string();
let mut id = [0u8; 32];
self.trng.borrow_mut().fill_bytes(&mut id);
let record = crate::AppInfo {
name,
id,
notes,
ctime: utc_now().timestamp() as u64,
atime: 0,
count: 0,
};
let ser = serialize_app_info(&record);
let app_id_str = hex::encode(id);
match self.pddb.borrow().get(
U2F_APP_DICT,
&app_id_str,
None, true, true,
Some(256), Some(crate::basis_change)
) {
Ok(mut app_data) => {
app_data.write(&ser).expect("couldn't create");
}
_ => log::error!("Error creating record"),
}
}
let xns = xous_names::XousNames::new().unwrap();
let mut rng = ctap_crypto::rng256::XousRng256::new(&xns);
for _ in 0..extra_fido {
use crate::ctap::data_formats::*;
let c_id = random_pick::pick_multiple_from_slice(&words, &weights, 2);
let cred_id = format!("{} {}", c_id[0], c_id[1]);
let r_id = random_pick::pick_multiple_from_slice(&words, &weights, 2);
let rp_id = format!("{} {}", r_id[0], r_id[1]);
let handle = random_pick::pick_from_slice(&words, &weights).unwrap().to_string();
let new_credential = PublicKeyCredentialSource {
key_type: PublicKeyCredentialType::PublicKey,
credential_id: cred_id.as_bytes().to_vec(),
private_key: ctap_crypto::ecdsa::SecKey::gensk(&mut rng),
rp_id,
user_handle: handle.as_bytes().to_vec(),
user_display_name: None,
cred_protect_policy: None,
creation_order: 0,
user_name: None,
user_icon: None,
};
let shortid = &cred_id;
match self.pddb.borrow().get(
FIDO_CRED_DICT,
shortid,
None, true, true,
Some(crate::ctap::storage::CRED_INITAL_SIZE), Some(crate::basis_change)
) {
Ok(mut cred) => {
let value = crate::ctap::storage::serialize_credential(new_credential).unwrap();
cred.write(&value).unwrap();
}
_ => log::error!("couldn't create FIDO2 credential")
}
}
}
// TOTP
let totp = self.pddb.borrow().list_keys(VAULT_TOTP_DICT, None).unwrap_or(Vec::new());
if totp.len() < TARGET_ENTRIES {
let extra = TARGET_ENTRIES - totp.len();
for _ in 0..extra {
let names = random_pick::pick_multiple_from_slice(&words, &weights, 3);
let name = format!("{} {} {}", names[0], names[1], names[2]);
let notes = random_pick::pick_from_slice(&words, &weights).unwrap().to_string();
let mut secret_bytes = [0u8; 10];
self.trng.borrow_mut().fill_bytes(&mut secret_bytes);
let record = TotpRecord {
version: VAULT_TOTP_REC_VERSION,
secret: base32::encode(base32::Alphabet::RFC4648 { padding: false }, &secret_bytes),
name,
algorithm: TotpAlgorithm::HmacSha1,
notes,
digits: 6,
timestep: 30,
ctime: utc_now().timestamp() as u64,
};
let ser = serialize_totp(&record);
let guid = self.gen_guid();
match self.pddb.borrow().get(
VAULT_TOTP_DICT,
&guid,
None, true, true,
Some(VAULT_TOTP_ALLOC_HINT), Some(crate::basis_change)
) {
Ok(mut data) => {
match data.write(&ser) {
Ok(len) => log::debug!("wrote {} bytes", len),
Err(e) => {
self.modals.show_notification(&format!("{}\n{:?}",
t!("vault.error.internal_error", xous::LANG), e
), None).ok();
}
}
}
Err(e) => {
self.modals.show_notification(&format!("{}\n{:?}",
t!("vault.error.internal_error", xous::LANG), e
), None).ok();
}
}
}
// specific TOTP entry with a known shared secret for testing
let record = TotpRecord {
version: VAULT_TOTP_REC_VERSION,
secret: "I65VU7K5ZQL7WB4E".to_string(),
name: "totp@authenticationtest.com".to_string(),
algorithm: TotpAlgorithm::HmacSha1,
notes: "Predefined test".to_string(),
digits: 6,
timestep: 30,
ctime: utc_now().timestamp() as u64,
};
let ser = serialize_totp(&record);
let guid = self.gen_guid();
match self.pddb.borrow().get(
VAULT_TOTP_DICT,
&guid,
None, true, true,
Some(VAULT_TOTP_ALLOC_HINT), Some(crate::basis_change)
) {
Ok(mut data) => {
match data.write(&ser) {
Ok(len) => log::debug!("wrote {} bytes", len),
Err(e) => {
self.modals.show_notification(&format!("{}\n{:?}",
t!("vault.error.internal_error", xous::LANG), e
), None).ok();
}
}
}
Err(e) => {
self.modals.show_notification(&format!("{}\n{:?}",
t!("vault.error.internal_error", xous::LANG), e
), None).ok();
}
}
}
self.pddb.borrow().sync().ok();
}
fn report_err<T: std::fmt::Debug>(&self, note: &str, e: Option<T>) {
log::error!("{}: {:?}", note, e);
if let Some(e) = e {
self.modals.show_notification(&format!("{}\n{:?}", note, e), None).ok();
} else {
self.modals.show_notification(&format!("{}", note), None).ok();
}
}
}
pub(crate) fn totp_ss_validator(input: TextEntryPayload) -> Option<xous_ipc::String<256>> {
let proposed_ss = input.as_str().to_uppercase();
if let Some(ss) = base32::decode(base32::Alphabet::RFC4648 { padding: false }, &proposed_ss) {
if ss.len() > 0 {
return None;
} else {
return Some(xous_ipc::String::<256>::from_str(t!("vault.illegal_totp", xous::LANG)));
}
}
if let Some(ss) = base32::decode(base32::Alphabet::RFC4648 { padding: true }, &proposed_ss) {
if ss.len() > 0 {
return None;
} else {
return Some(xous_ipc::String::<256>::from_str(t!("vault.illegal_totp", xous::LANG)));
}
}
if let Some(ss) = base32::decode(base32::Alphabet::Crockford, &proposed_ss) {
if ss.len() > 0 {
return None;
} else {
return Some(xous_ipc::String::<256>::from_str(t!("vault.illegal_totp", xous::LANG)));
}
}
Some(xous_ipc::String::<256>::from_str(t!("vault.illegal_totp", xous::LANG)))
}
pub(crate) fn name_validator(input: TextEntryPayload) -> Option<xous_ipc::String<256>> {
let proposed_name = input.as_str();
if proposed_name.contains('\n') { // the '\n' is reserved as the delimiter to end the name field
@ -766,12 +1221,94 @@ pub(crate) fn deserialize_password(data: Vec::<u8>) -> Option<PasswordRecord> {
}
}
_ => {
log::warn!("unexpected tag {} encountered parsing app info, aborting", tag);
return None;
log::warn!("unexpected tag {} encountered parsing password info, ignoring", tag);
}
}
} else {
log::debug!("invalid line skipped: {:?}", line);
log::trace!("invalid line skipped: {:?}", line);
}
}
Some(pr)
} else {
None
}
}
pub(crate) fn serialize_totp<'a>(record: &TotpRecord) -> Vec::<u8> {
let ta: String = record.algorithm.into();
format!("{}:{}\n{}:{}\n{}:{}\n{}:{}\n{}:{}\n{}:{}\n{}:{}\n{}:{}\n",
"version", record.version,
"secret", record.secret,
"name", record.name,
"algorithm", ta,
"notes", record.notes,
"digits", record.digits,
"timestep", record.timestep,
"ctime", record.ctime,
).into_bytes()
}
pub(crate) fn deserialize_totp(data: Vec::<u8>) -> Option<TotpRecord> {
if let Ok(desc_str) = String::from_utf8(data) {
let mut pr = TotpRecord {
version: 0,
secret: String::new(),
name: String::new(),
algorithm: TotpAlgorithm::HmacSha1,
notes: String::new(),
digits: 0,
ctime: 0,
timestep: 0,
};
let lines = desc_str.split('\n');
for line in lines {
if let Some((tag, data)) = line.split_once(':') {
match tag {
"version" => {
if let Ok(ver) = u32::from_str_radix(data, 10) {
pr.version = ver
} else {
log::warn!("ver error");
return None;
}
}
"secret" => pr.secret.push_str(data),
"name" => pr.name.push_str(data),
"algorithm" => pr.algorithm = match TotpAlgorithm::try_from(data) {
Ok(a) => a,
Err(_) => return None
},
"notes" => pr.notes.push_str(data),
"digits" => {
if let Ok(digits) = u32::from_str_radix(data, 10) {
pr.digits = digits;
} else {
log::warn!("digits error");
return None;
}
}
"ctime" => {
if let Ok(ctime) = u64::from_str_radix(data, 10) {
pr.ctime = ctime;
} else {
log::warn!("ctime error");
return None;
}
}
"timestep" => {
if let Ok(timestep) = u64::from_str_radix(data, 10) {
pr.timestep = timestep;
} else {
log::warn!("timestep error");
return None;
}
}
_ => {
log::warn!("unexpected tag {} encountered parsing TOTP info, ignoring", tag);
}
}
} else {
log::trace!("invalid line skipped: {:?}", line);
}
}
Some(pr)

View file

@ -22,7 +22,7 @@ mod key_material;
mod pin_protocol_v1;
pub mod response;
pub mod status_code;
mod storage;
pub mod storage;
mod timed_permission;
#[cfg(feature = "with_ctap2_1")]

View file

@ -43,7 +43,7 @@ use super::CREDENTIAL_ID_SIZE;
/// credentials, but what happens in this case is just a re-allocation in the PDDB.
/// Whereas if this number is "too big" you end up with wasted space. I think a
/// typical record will be around 300-400 bytes, so, this is a good compromise.
const CRED_INITAL_SIZE: usize = 512;
pub(crate) const CRED_INITAL_SIZE: usize = 512;
// Those constants may be modified before compilation to tune the behavior of the key.
//
@ -149,10 +149,8 @@ impl PersistentStore {
}
// Generate and store the CredRandom secrets if they are missing.
// note this goes into the FIDO_CRED_DICT, in order to force its creation.
// It does mean we have a special case key in the dictionary.
match self.pddb.borrow().get(
FIDO_CRED_DICT,
FIDO_DICT,
key::CRED_RANDOM_SECRET,
None, true, true,
Some(64), Some(crate::basis_change)
@ -415,7 +413,10 @@ openssl asn1parse -in opensk_cert.pem -inform pem
}
Err(e) => match e.kind() {
std::io::ErrorKind::NotFound => Ok(None),
_ => Err(Ctap2StatusCode::CTAP2_ERR_VENDOR_INTERNAL_ERROR), // PDDB internal error
_ => {
log::error!("PDDB internal error in find_credential: {:?}", e);
Err(Ctap2StatusCode::CTAP2_ERR_VENDOR_INTERNAL_ERROR)
}, // PDDB internal error
}
}
}
@ -431,7 +432,7 @@ openssl asn1parse -in opensk_cert.pem -inform pem
match self.pddb.borrow().get(
FIDO_CRED_DICT,
&shortid,
None, false, true,
None, true, true,
Some(CRED_INITAL_SIZE), Some(crate::basis_change)
) {
Ok(mut cred) => {
@ -455,9 +456,8 @@ openssl asn1parse -in opensk_cert.pem -inform pem
check_cred_protect: bool,
) -> Result<Vec<PublicKeyCredentialSource>, Ctap2StatusCode> {
let mut result = Vec::<PublicKeyCredentialSource>::new();
let mut cred_list = self.pddb.borrow().list_keys(
FIDO_CRED_DICT, None).or(Err(Ctap2StatusCode::CTAP2_ERR_VENDOR_INTERNAL_ERROR))?;
cred_list.retain(|name| name != key::CRED_RANDOM_SECRET); // don't try to investigate this one key
let cred_list = self.pddb.borrow().list_keys(
FIDO_CRED_DICT, None).unwrap_or(Vec::new());
for cred_name in cred_list.iter() {
if let Some(mut cred_entry) = self.pddb.borrow().get(
FIDO_CRED_DICT,
@ -482,17 +482,15 @@ openssl asn1parse -in opensk_cert.pem -inform pem
#[cfg(test)]
pub fn count_credentials(&self) -> Result<usize, Ctap2StatusCode> {
let mut cred_list = self.pddb.borrow().list_keys(
FIDO_CRED_DICT, None).or(Err(Ctap2StatusCode::CTAP2_ERR_VENDOR_INTERNAL_ERROR))?;
cred_list.retain(|name| name != key::CRED_RANDOM_SECRET); // don't count this special case key
FIDO_CRED_DICT, None).unwrap_or(Vec::new());
Ok(cred_list.len())
}
/// Returns the next creation order.
pub fn new_creation_order(&self) -> Result<u64, Ctap2StatusCode> {
let mut max = 0;
let mut cred_list = self.pddb.borrow().list_keys(
FIDO_CRED_DICT, None).or(Err(Ctap2StatusCode::CTAP2_ERR_VENDOR_INTERNAL_ERROR))?;
cred_list.retain(|name| name != key::CRED_RANDOM_SECRET); // don't try to investigate this one key
let cred_list = self.pddb.borrow().list_keys(
FIDO_CRED_DICT, None).unwrap_or(Vec::new());
if cred_list.len() == 0 {
return Ok(0)
}
@ -588,7 +586,7 @@ openssl asn1parse -in opensk_cert.pem -inform pem
/// Returns the CredRandom secret.
pub fn cred_random_secret(&self, has_uv: bool) -> Result<[u8; 32], Ctap2StatusCode> {
match self.pddb.borrow().get(
FIDO_CRED_DICT,
FIDO_DICT,
key::CRED_RANDOM_SECRET,
None, false, false, None, Some(crate::basis_change)
) {
@ -1000,13 +998,13 @@ openssl asn1parse -in opensk_cert.pem -inform pem
}
/// Deserializes a credential from storage representation.
fn deserialize_credential(data: &[u8]) -> Option<PublicKeyCredentialSource> {
pub(crate) fn deserialize_credential(data: &[u8]) -> Option<PublicKeyCredentialSource> {
let cbor = cbor::read(data).ok()?;
cbor.try_into().ok()
}
/// Serializes a credential to storage representation.
fn serialize_credential(credential: PublicKeyCredentialSource) -> Result<Vec<u8>, Ctap2StatusCode> {
pub(crate) fn serialize_credential(credential: PublicKeyCredentialSource) -> Result<Vec<u8>, Ctap2StatusCode> {
let mut data = Vec::new();
if cbor::write(credential.into(), &mut data) {
Ok(data)

View file

@ -19,6 +19,7 @@ mod shims;
use shims::*;
mod submenu;
mod actions;
mod totp;
use locales::t;
@ -80,6 +81,25 @@ UI concept:
- Icontray thread: a simple server that serves as a shim between the IME structure and this to create an icontray function
*/
// TOTP test I65VU7K5ZQL7WB4E https://authenticationtest.com/totpChallenge/
// otpauth-migration://offline?data=Ci8KCke7Wn1dzBf7B4QSG3RvdHBAYXV0aGVudGljYXRpb250ZXN0LmNvbSABKAEwAhABGAEgACjh8Yv%2B%2BP%2F%2F%2F%2F8B
/*
otp_parameters {
secret: "G\273Z}]\314\027\373\007\204"
name: "totp@authenticationtest.com"
algorithm: SHA1
digits: SIX
type: TOTP
}
version: 1
batch_size: 1
batch_index: 0
batch_id: -1883047711
>>> b32decode("I65VU7K5ZQL7WB4E").hex()
'47bb5a7d5dcc17fb0784'
*/
#[derive(Debug, num_derive::FromPrimitive, num_derive::ToPrimitive)]
pub(crate) enum VaultOp {
/// a line of text has arrived
@ -203,6 +223,10 @@ fn main() -> ! {
icontray_server(conn);
}
});
// spawn the TOTP pumper
let pump_sid = xous::create_server().unwrap();
crate::totp::pumper(mode.clone(), pump_sid, conn);
let pump_conn = xous::connect(pump_sid).unwrap();
let menu_sid = xous::create_server().unwrap();
let menu_mgr = submenu::create_submenu(conn, actions_conn, menu_sid);
@ -268,6 +292,10 @@ fn main() -> ! {
Message::new_blocking_scalar(ActionOp::UpdateMode.to_usize().unwrap(), 0, 0, 0, 0)
).ok();
vaultux.update_mode();
// this will start a periodic pump to keep the UX updating
send_message(pump_conn,
Message::new_scalar(totp::PumpOp::Pump.to_usize().unwrap(), 0, 0, 0, 0)
).ok();
}
"\u{0013}" => {
*mode.lock().unwrap() = VaultMode::Password;

View file

@ -29,6 +29,14 @@ pub fn create_submenu(vault_conn: xous::CID, actions_conn: xous::CID, menu_mgr:
action_payload: MenuPayload::Scalar([0, 0, 0, 0]),
close_on_select: true,
});
#[cfg(feature="testing")]
menu_items.push(MenuItem {
name: xous_ipc::String::from_str("Generate test vectors"),
action_conn: Some(actions_conn),
action_opcode: ActionOp::GenerateTests.to_u32().unwrap(),
action_payload: MenuPayload::Scalar([0, 0, 0, 0]),
close_on_select: true,
});
menu_items.push(MenuItem {
name: xous_ipc::String::from_str(t!("vault.menu_close", xous::LANG)),
action_conn: Some(actions_conn),

177
apps/vault/src/totp.rs Normal file
View file

@ -0,0 +1,177 @@
use crypto_mac::InvalidKeyLength;
use sha1::Sha1;
use hmac::{Hmac, Mac, NewMac};
use std::{
convert::TryFrom,
time::{SystemTime, SystemTimeError},
};
use std::sync::{Arc, Mutex};
use xous::{Message, send_message};
use std::thread;
use crate::VaultMode;
use num_traits::*;
// Derived from https://github.com/blakesmith/xous-core/blob/xtotp-time/apps/xtotp/src/main.rs
#[derive(Clone, Copy)]
pub(crate) enum TotpAlgorithm {
HmacSha1,
HmacSha256,
HmacSha512,
}
impl std::fmt::Debug for TotpAlgorithm {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
match self {
TotpAlgorithm::HmacSha1 => write!(f, "SHA1"),
TotpAlgorithm::HmacSha256 => write!(f, "SHA256"),
TotpAlgorithm::HmacSha512 => write!(f, "SHA512"),
}
}
}
impl TryFrom<&str> for TotpAlgorithm {
type Error = xous::Error;
fn try_from(s: &str) -> Result<Self, Self::Error> {
match s {
"SHA1" => Ok(TotpAlgorithm::HmacSha1),
"SHA256" => Ok(TotpAlgorithm::HmacSha256),
"SHA512" => Ok(TotpAlgorithm::HmacSha512),
_ => Err(xous::Error::InvalidString)
}
}
}
impl Into<String> for TotpAlgorithm {
fn into(self) -> String {
match self {
TotpAlgorithm::HmacSha1 => "SHA1".to_string(),
TotpAlgorithm::HmacSha256 => "SHA256".to_string(),
TotpAlgorithm::HmacSha512 => "SHA512".to_string(),
}
}
}
#[derive(Debug)]
pub(crate) struct TotpEntry {
pub step_seconds: u16,
pub shared_secret: Vec<u8>,
pub digit_count: u8,
pub algorithm: TotpAlgorithm,
}
#[derive(Debug)]
pub(crate) enum Error {
Io(std::io::Error),
DigestLength(InvalidKeyLength),
}
impl From<std::io::Error> for Error {
fn from(err: std::io::Error) -> Self {
Error::Io(err)
}
}
impl From<InvalidKeyLength> for Error {
fn from(err: InvalidKeyLength) -> Self {
Error::DigestLength(err)
}
}
pub(crate) fn get_current_unix_time() -> Result<u64, SystemTimeError> {
SystemTime::now()
.duration_since(SystemTime::UNIX_EPOCH)
.map(|duration| duration.as_secs())
}
fn unpack_u64(v: u64) -> [u8; 8] {
let mask = 0x00000000000000ff;
let mut bytes: [u8; 8] = [0; 8];
(0..8).for_each(|i| bytes[7 - i] = (mask & (v >> (i * 8))) as u8);
bytes
}
fn generate_hmac_bytes(unix_timestamp: u64, totp_entry: &TotpEntry) -> Result<Vec<u8>, Error> {
let mut computed_hmac = Vec::new();
match totp_entry.algorithm {
// The OpenTitan HMAC core does not support hmac-sha1. Fall back to
// a software implementation.
TotpAlgorithm::HmacSha1 => {
let mut mac: Hmac<Sha1> = Hmac::new_from_slice(&totp_entry.shared_secret)?;
mac.update(&unpack_u64(unix_timestamp / totp_entry.step_seconds as u64));
let hash: &[u8] = &mac.finalize().into_bytes();
computed_hmac.extend_from_slice(hash);
}
// note: sha256/sha512 implementations not yet tested, as we have yet to find a site that uses this to test against.
TotpAlgorithm::HmacSha256 => {
let mut mac: Hmac<sha2::Sha256> = Hmac::new_from_slice(&totp_entry.shared_secret)?;
mac.update(&unpack_u64(unix_timestamp / totp_entry.step_seconds as u64));
let hash: &[u8] = &mac.finalize().into_bytes();
computed_hmac.extend_from_slice(hash);
}
TotpAlgorithm::HmacSha512 => {
let mut mac: Hmac<sha2::Sha512> = Hmac::new_from_slice(&totp_entry.shared_secret)?;
mac.update(&unpack_u64(unix_timestamp / totp_entry.step_seconds as u64));
let hash: &[u8] = &mac.finalize().into_bytes();
computed_hmac.extend_from_slice(hash);
}
}
Ok(computed_hmac)
}
pub(crate) fn generate_totp_code(unix_timestamp: u64, totp_entry: &TotpEntry) -> Result<String, Error> {
let hash = generate_hmac_bytes(unix_timestamp, totp_entry)?;
let offset: usize = (hash.last().unwrap_or(&0) & 0xf) as usize;
let binary: u64 = (((hash[offset] & 0x7f) as u64) << 24)
| ((hash[offset + 1] as u64) << 16)
| ((hash[offset + 2] as u64) << 8)
| (hash[offset + 3] as u64);
let truncated_code = format!(
"{:01$}",
binary % (10_u64.pow(totp_entry.digit_count as u32)),
totp_entry.digit_count as usize
);
Ok(truncated_code)
}
#[derive(Debug, num_derive::FromPrimitive, num_derive::ToPrimitive)]
pub(crate) enum PumpOp {
Pump,
Quit,
}
pub(crate) fn pumper(mode: Arc<Mutex<VaultMode>>, sid: xous::SID, main_conn: xous::CID) {
let _ = thread::spawn({
move || {
let tt = ticktimer_server::Ticktimer::new().unwrap();
let self_conn = xous::connect(sid).unwrap();
loop {
let msg = xous::receive_message(sid).unwrap();
let opcode: Option<PumpOp> = FromPrimitive::from_usize(msg.body.id());
log::trace!("{:?}", opcode);
match opcode {
Some(PumpOp::Pump) => {
send_message(main_conn,
Message::new_scalar(crate::VaultOp::Redraw.to_usize().unwrap(),
0, 0, 0, 0)
).expect("couldn't pump redraw");
let mode_cache = {(*mode.lock().unwrap()).clone()};
{ // we really want mode.lock() to be in a different scope so...
if mode_cache == VaultMode::Totp {
tt.sleep_ms(2000).unwrap();
send_message(self_conn,
Message::new_scalar(PumpOp::Pump.to_usize().unwrap(),
0, 0, 0, 0)
).expect("couldn't restart pump");
}
}
// if not in Totp mode, the restart message doesn't go through, and the redraws automatically stop.
},
Some(PumpOp::Quit) => {break;}
_ => log::warn!("couldn't parse message: {:?}", msg),
}
}
xous::destroy_server(sid).ok();
}
});
}

View file

@ -554,7 +554,7 @@ pub(crate) fn deserialize_app_info(descriptor: Vec::<u8>) -> Option::<AppInfo> {
}
}
} else {
log::debug!("invalid line skipped: {:?}", line);
log::trace!("invalid line skipped: {:?}", line);
}
}
if appinfo.name.len() > 0

View file

@ -1,4 +1,5 @@
use crate::*;
use crate::totp::{TotpAlgorithm, generate_totp_code};
use gam::{UxRegistration, GlyphStyle, MenuMatic, MenuItem, MenuPayload};
use graphics_server::{Gid, Point, Rectangle, DrawStyle, PixelColor, TextView};
use std::fmt::Write;
@ -8,6 +9,7 @@ use std::cmp::Ordering;
use std::io::{Read, Write as FsWrite};
use actions::ActionOp;
use std::sync::atomic::Ordering as AtomicOrdering;
use std::convert::TryFrom;
/// Display list for items. "name" is the key by which the list is sorted.
/// "extra" is more information about the item, which should not be part of the sort.
@ -87,6 +89,10 @@ pub(crate) struct VaultUx {
/// usb interface
usb_dev: usb_device_xous::UsbHid,
/// totp redraw state
last_epoch: u64,
current_time: u64,
}
pub(crate) const DEFAULT_FONT: GlyphStyle = GlyphStyle::Regular;
@ -153,6 +159,7 @@ impl VaultUx {
let pddb = pddb::Pddb::new();
// TODO: put some informative message asking to mount the PDDB if it's not mounted, right now you just get a blank screen.
// TODO: also add routines to detect if time is not set up, and block initialization until that happens.
pddb.is_mounted_blocking();
// temporary style setting, this will get over-ridden after init
let style = GlyphStyle::Regular;
@ -161,6 +168,8 @@ impl VaultUx {
let item_height = (glyph_height * 2) as i16 + margin.y * 2 + 2; // +2 because of the border width
let items_per_screen = available_height / item_height;
let current_time = totp::get_current_unix_time().unwrap_or(0);
VaultUx {
content,
gam,
@ -181,6 +190,8 @@ impl VaultUx {
actions_conn,
action_active,
usb_dev: usb_device_xous::UsbHid::new(),
last_epoch: current_time / 30,
current_time,
}
}
@ -456,7 +467,27 @@ impl VaultUx {
}
pub(crate) fn redraw(&mut self) -> Result<(), xous::Error> {
// to reduce locking thrash, we cache a copy of the current mode at the top of redraw.
// this could lead to some race conditions that lead to awkward problems, we'll see, but it
// is probably worth the performance improvement.
let mode_at_entry = (*self.mode.lock().unwrap()).clone();
if mode_at_entry == VaultMode::Totp { // always redraw the title in TOTP mode
self.title_dirty = true;
// always grab the current time, regardless of the mode? saves an extra call to get time...
self.current_time = totp::get_current_unix_time().unwrap_or(0);
// duration bar is hard-coded to once every 30 seconds, even if the keys may not change that often.
let epoch = self.current_time / 30;
if self.last_epoch != epoch {
self.last_epoch = epoch;
// force a redraw of all the items if the epoch has changed
for item in self.filtered_list.iter_mut() {
item.dirty = true;
}
}
}
self.clear_area();
// ---- draw title area ----
if self.title_dirty || self.action_active.load(AtomicOrdering::SeqCst) {
let mut title_text = TextView::new(self.content,
@ -470,12 +501,28 @@ impl VaultUx {
title_text.draw_border = false;
title_text.clear_area = true;
title_text.style = GlyphStyle::Large;
match *self.mode.lock().unwrap() {
match mode_at_entry {
VaultMode::Fido => write!(title_text, "FIDO").ok(),
VaultMode::Totp => write!(title_text, "⏳1234").ok(),
VaultMode::Password => write!(title_text, "🔐****").ok(),
};
self.gam.post_textview(&mut title_text).expect("couldn't post title");
if mode_at_entry == VaultMode::Totp {
const BAR_HEIGHT: i16 = 5;
const BAR_GAP: i16 = -10;
// draw the duration bar
let delta = (self.current_time - (self.last_epoch * 30)) as i32;
let width = (self.screensize.x - (self.margin.x * 2)) as i32;
let delta_width = (delta * width * 100) / (30 * 100);
self.gam.draw_rectangle(
self.content,
Rectangle {
tl: Point::new(self.margin.x, TITLE_HEIGHT - (BAR_HEIGHT + BAR_GAP)),
br: Point::new(self.screensize.x - self.margin.x - delta_width as i16, TITLE_HEIGHT - BAR_GAP),
style: DrawStyle { fill_color: Some(PixelColor::Dark), stroke_color: None, stroke_width: 0 }
}
).ok();
}
self.title_dirty = false;
}
if self.action_active.load(AtomicOrdering::SeqCst) {
@ -532,7 +579,35 @@ impl VaultUx {
if index == selected as usize {
box_text.border_width = 4;
}
write!(box_text, "{}\n{}", item.name, item.extra).ok();
match mode_at_entry {
VaultMode::Fido | VaultMode::Password => {write!(box_text, "{}\n{}", item.name, item.extra).ok();},
VaultMode::Totp => {
let fields = item.extra.split(':').collect::<Vec<&str>>();
if fields.len() == 4 {
let shared_secret = base32::decode(
base32::Alphabet::RFC4648 { padding: false }, fields[0])
.unwrap_or(vec![]);
let digit_count = u8::from_str_radix(fields[1], 10).unwrap_or(6);
let step_seconds = u16::from_str_radix(fields[2], 10).unwrap_or(30);
let algorithm = TotpAlgorithm::try_from(fields[2]).unwrap_or(TotpAlgorithm::HmacSha1);
let totp = totp::TotpEntry {
step_seconds,
shared_secret,
digit_count,
algorithm
};
let code = generate_totp_code(
totp::get_current_unix_time().unwrap_or(0),
&totp
).unwrap_or(t!("vault.error.record_error", xous::LANG).to_string());
// why code on top? because the item.name can be very long, and it can wrap which would cause
// the code to become hidden.
write!(box_text, "{}\n{}", code, item.name).ok();
} else {
write!(box_text, "{}", t!("vault.error.record_error", xous::LANG)).ok();
}
},
}
self.gam.post_textview(&mut box_text).expect("couldn't post list item");
item.dirty = false;
}