Merge branch 'u2f' into main

Merge in the latest progress as it includes some fixes to the PDDB
(read_all() now works as expected), and to the keyboard listener
API on the dynamic notifications dialog box.
This commit is contained in:
bunnie 2022-06-05 01:53:41 +08:00
commit 9bd39af684
18 changed files with 897 additions and 81 deletions

2
Cargo.lock generated
View file

@ -3773,10 +3773,12 @@ dependencies = [
"locales",
"log",
"log-server",
"modals",
"num-derive",
"num-traits",
"pddb",
"rand_core 0.6.3",
"rkyv",
"subtle",
"ticktimer-server",
"tts-frontend",

View file

@ -9,6 +9,7 @@ num-derive = {version = "0.3.3", default-features = false}
num-traits = {version = "0.2.14", default-features = false}
xous = { path = "../../xous-rs" }
xous-ipc = { path = "../../xous-ipc" }
rkyv = {version = "0.4.3", features = ["const_generics"], default-features = false}
log-server = { path = "../../services/log-server" }
xous-names = { path = "../../services/xous-names" }
gam = {path = "../../services/gam" }
@ -18,6 +19,7 @@ tts-frontend = {path="../../services/tts"}
usb-device-xous = {path="../../services/usb-device-xous"}
usbd-human-interface-device = {git="https://github.com/betrusted-io/usbd-human-interface-device.git", branch="main"}
pddb = {path = "../../services/pddb" }
modals = {path = "../../services/modals" }
ime-plugin-api = {path = "../../services/ime-plugin-api"}
ime-plugin-shell = {path = "../../services/ime-plugin-shell"}

View file

@ -1,8 +1,26 @@
{
"helloworld.hello": {
"en": "Hello World!",
"ja": "Hello World!",
"zh": "大家好!",
"en-tts": "Hello World!"
"vault.u2f.authenticate": {
"en": "U2F Authentication Request",
"ja": "U2F 認証リクエスト",
"zh": "U2F 认证请求",
"en-tts": "U2F Authentication Request"
},
"vault.u2f.apphash": {
"en": "Application hash: ",
"ja": "アプリハッシュ: ",
"zh": "应用哈希: ",
"en-tts": "Application hash: "
},
"vault.u2f.register": {
"en": "U2F Registration Request",
"ja": "U2F登録リクエスト",
"zh": "U2F 注册请求",
"en-tts": "U2F Registration Request"
},
"vault.u2freq": {
"en": "FIDO Request",
"ja": "FIDOリクエスト",
"zh": "FIDO 请求",
"en-tts": "FIDO Request"
}
}

View file

@ -21,7 +21,7 @@ const APDU_HEADER_LEN: usize = 4;
#[cfg_attr(test, derive(Clone, Debug))]
#[allow(non_camel_case_types, dead_code)]
#[derive(PartialEq)]
#[derive(PartialEq, Debug)]
pub enum ApduStatusCode {
SW_SUCCESS = 0x90_00,
/// Command successfully executed; 'XX' bytes of data are

View file

@ -22,6 +22,7 @@ use core::convert::Into;
use core::convert::TryFrom;
use ctap_crypto::rng256::Rng256;
use crate::shims::ClockValue;
use locales::t;
// For now, they're the same thing with apdu.rs containing the authoritative definition
pub type Ctap1StatusCode = ApduStatusCode;
@ -197,10 +198,13 @@ impl Ctap1Command {
application,
} => {
log::debug!("REGISTER");
if !ctap_state.u2f_up_state.consume_up(clock_value) {
log::debug!("consume_up did not work");
let mut regstr = String::from(t!("vault.u2f.register", xous::LANG));
regstr.push_str(&format!("\n{}\n{:x?}", t!("vault.u2f.apphash", xous::LANG), application));
if !ctap_state.u2f_up_state.consume_up(clock_value, regstr) {
log::debug!("still waiting...");
return Err(Ctap1StatusCode::SW_COND_USE_NOT_SATISFIED);
}
log::debug!("GOT IT!...");
Ctap1Command::process_register(challenge, application, ctap_state)
}
@ -211,9 +215,11 @@ impl Ctap1Command {
flags,
} => {
log::debug!("AUTHENTICATE");
let mut authstr = String::from(t!("vault.u2f.authenticate", xous::LANG));
authstr.push_str(&format!("\n{}\n{:x?}", t!("vault.u2f.apphash", xous::LANG), application));
// The order is important due to side effects of checking user presence.
if flags == Ctap1Flags::EnforceUpAndSign
&& !ctap_state.u2f_up_state.consume_up(clock_value)
&& !ctap_state.u2f_up_state.consume_up(clock_value, authstr)
{
return Err(Ctap1StatusCode::SW_COND_USE_NOT_SATISFIED);
}
@ -266,6 +272,7 @@ impl Ctap1Command {
.encrypt_key_handle(sk, &application)
.map_err(|_| Ctap1StatusCode::SW_INTERNAL_EXCEPTION)?;
if key_handle.len() > 0xFF {
log::info!("key_handle.len() invalid");
// This is just being defensive with unreachable code.
return Err(Ctap1StatusCode::SW_INTERNAL_EXCEPTION);
}
@ -301,6 +308,7 @@ impl Ctap1Command {
let signature = attestation_key.sign_rfc6979::<ctap_crypto::sha256::Sha256>(&signature_data);
response.extend(signature.to_asn1_der());
log::info!("process_register response: {:x?}", &response[..32]);
Ok(response)
}

View file

@ -157,6 +157,7 @@ impl CtapHid {
CheckUserPresence: Fn(ChannelID) -> Result<(), Ctap2StatusCode>,
{
// TODO: Send COMMAND_KEEPALIVE every 100ms?
log::info!("now: {}", clock_value.ms());
match self
.assembler
.parse_packet(packet, Timestamp::<i64>::from_clock_value(clock_value))
@ -188,8 +189,12 @@ impl CtapHid {
ctap_state,
clock_value,
) {
Ok(payload) => CtapHid::ctap1_success_message(cid, &payload),
Ok(payload) => {
log::info!("command success: {:x?}", payload);
CtapHid::ctap1_success_message(cid, &payload)
},
Err(ctap1_status_code) => {
log::info!("command failure: {:?}", ctap1_status_code);
CtapHid::ctap1_error_message(cid, ctap1_status_code)
}
}

View file

@ -89,7 +89,7 @@ impl MessageAssembler {
// TODO: Support non-full-speed devices (i.e. packet len != 64)? This isn't recommended by
// section 8.8.1
let (cid, processed_packet) = CtapHid::process_single_packet(&packet);
log::debug!("parsed cid: {:x?}", cid);
log::trace!("parsed cid: {:x?}", cid);
if !self.idle && timestamp - self.last_timestamp >= CtapHid::TIMEOUT_DURATION {
log::debug!("parse timeout");

View file

@ -63,6 +63,7 @@ const CRED_INITAL_SIZE: usize = 512;
// We have: I = (P * 4084 - 5107 - K * S) / 8 * C
//
// With P=20 and K=150, we have I=2M which is enough for 500 increments per day for 10 years.
#[allow(dead_code)] // openSK legacy
const NUM_PAGES: usize = 20;
#[allow(dead_code)] // OpenSK legacy
const MAX_SUPPORTED_RESIDENTIAL_KEYS: usize = 150;
@ -96,6 +97,15 @@ pub struct PersistentStore {
pddb: RefCell::<Pddb>,
}
use std::num::ParseIntError;
pub fn decode_hex(s: &str) -> Result<Vec<u8>, ParseIntError> {
(0..s.len())
.step_by(2)
.map(|i| u8::from_str_radix(&s[i..i + 2], 16))
.collect()
}
impl PersistentStore {
/// Gives access to the persistent store.
///
@ -182,8 +192,110 @@ impl PersistentStore {
}
_ => return Err(Ctap2StatusCode::CTAP2_ERR_VENDOR_INTERNAL_ERROR),
}
/*
match self.pddb.borrow().get(
FIDO_PERSISTENT_DICT,
key::ATTESTATION_PRIVATE_KEY,
None, true, true,
Some(32), None::<fn()>
) {
Ok(mut aapriv) => {
let aapriv_attr = aapriv.attributes().unwrap();
if aapriv_attr.len != 32 {
if aapriv_attr.len != 0 {
log::error!("AAPRIV has an illegal length. Suspect PDDB corruption?");
return Err(Ctap2StatusCode::CTAP2_ERR_INVALID_CREDENTIAL);
}
let pk = decode_hex("497b200642e71e4ed929359a19aa701b42f3a304bd7e79c4a25b5af2635b2db1").unwrap();
log::info!("writing PK of length {}", pk.len());
log::info!("pk: {:x?}", pk);
assert!(pk.len() == 32, "PK len is wrong");
aapriv.write(&pk)
.or(Err(Ctap2StatusCode::CTAP2_ERR_VENDOR_INTERNAL_ERROR))?;
}
}
_ => return Err(Ctap2StatusCode::CTAP2_ERR_VENDOR_INTERNAL_ERROR),
}
match self.pddb.borrow().get(
FIDO_PERSISTENT_DICT,
key::ATTESTATION_CERTIFICATE,
None, true, true,
Some(512), None::<fn()>
) {
Ok(mut cert) => {
let cert_attr = cert.attributes().unwrap();
if cert_attr.len == 0 {
let der = decode_hex("308201283081cf021427bf2c7cc29ae91ffb3d4bb99f25fcda6fb407be300a06082a8648ce3d04030230173115301306035504030c0c507265637572736f72204341301e170d3232303630343136313231335a170d3432303630343136313231335a30173115301306035504030c0c507265637572736f722043413059301306072a8648ce3d020106082a8648ce3d03010703420004a4439a22be033f90e8a160ddd5b3552635f3d951d26724a3e453c8438fb2f9cc32c78e413323c438d276a2e3b081be118f516c4e7cb64455c46b5a4bbca85d04300a06082a8648ce3d0403020348003045022008e4e46b48d462a380be08841a9d9da946aef3948e7e7bd8da51dafeea4d563f022100bd3ef23d840dc653fa821f2e0ae940b91f495b692fb7e94588e6fd3ed7d0a3ae").unwrap();
log::info!("writing cert of length {}", der.len());
log::info!("der: {:x?}", der);
cert.write(&der)
.or(Err(Ctap2StatusCode::CTAP2_ERR_VENDOR_INTERNAL_ERROR))?;
}
}
_ => return Err(Ctap2StatusCode::CTAP2_ERR_VENDOR_INTERNAL_ERROR),
}
*/
Ok(())
}
/*
openssl x509 -in cert.der -inform der -noout -text
Certificate:
Data:
Version: 1 (0x0)
Serial Number:
27:bf:2c:7c:c2:9a:e9:1f:fb:3d:4b:b9:9f:25:fc:da:6f:b4:07:be
Signature Algorithm: ecdsa-with-SHA256
Issuer: CN = Precursor CA
Validity
Not Before: Jun 4 16:12:13 2022 GMT
Not After : Jun 4 16:12:13 2042 GMT
Subject: CN = Precursor CA
Subject Public Key Info:
Public Key Algorithm: id-ecPublicKey
Public-Key: (256 bit)
pub:
04:a4:43:9a:22:be:03:3f:90:e8:a1:60:dd:d5:b3:
55:26:35:f3:d9:51:d2:67:24:a3:e4:53:c8:43:8f:
b2:f9:cc:32:c7:8e:41:33:23:c4:38:d2:76:a2:e3:
b0:81:be:11:8f:51:6c:4e:7c:b6:44:55:c4:6b:5a:
4b:bc:a8:5d:04
ASN1 OID: prime256v1
NIST CURVE: P-256
Signature Algorithm: ecdsa-with-SHA256
30:45:02:20:08:e4:e4:6b:48:d4:62:a3:80:be:08:84:1a:9d:
9d:a9:46:ae:f3:94:8e:7e:7b:d8:da:51:da:fe:ea:4d:56:3f:
02:21:00:bd:3e:f2:3d:84:0d:c6:53:fa:82:1f:2e:0a:e9:40:
b9:1f:49:5b:69:2f:b7:e9:45:88:e6:fd:3e:d7:d0:a3:ae
openssl asn1parse -in cert.der -inform der
0:d=0 hl=4 l= 296 cons: SEQUENCE
4:d=1 hl=3 l= 207 cons: SEQUENCE
7:d=2 hl=2 l= 20 prim: INTEGER :27BF2C7CC29AE91FFB3D4BB99F25FCDA6FB407BE
29:d=2 hl=2 l= 10 cons: SEQUENCE
31:d=3 hl=2 l= 8 prim: OBJECT :ecdsa-with-SHA256
41:d=2 hl=2 l= 23 cons: SEQUENCE
43:d=3 hl=2 l= 21 cons: SET
45:d=4 hl=2 l= 19 cons: SEQUENCE
47:d=5 hl=2 l= 3 prim: OBJECT :commonName
52:d=5 hl=2 l= 12 prim: UTF8STRING :Precursor CA
66:d=2 hl=2 l= 30 cons: SEQUENCE
68:d=3 hl=2 l= 13 prim: UTCTIME :220604161213Z
83:d=3 hl=2 l= 13 prim: UTCTIME :420604161213Z
98:d=2 hl=2 l= 23 cons: SEQUENCE
100:d=3 hl=2 l= 21 cons: SET
102:d=4 hl=2 l= 19 cons: SEQUENCE
104:d=5 hl=2 l= 3 prim: OBJECT :commonName
109:d=5 hl=2 l= 12 prim: UTF8STRING :Precursor CA
123:d=2 hl=2 l= 89 cons: SEQUENCE
125:d=3 hl=2 l= 19 cons: SEQUENCE
127:d=4 hl=2 l= 7 prim: OBJECT :id-ecPublicKey
136:d=4 hl=2 l= 8 prim: OBJECT :prime256v1
146:d=3 hl=2 l= 66 prim: BIT STRING
214:d=1 hl=2 l= 10 cons: SEQUENCE
216:d=2 hl=2 l= 8 prim: OBJECT :ecdsa-with-SHA256
226:d=1 hl=2 l= 72 prim: BIT STRING
*/
/// The credential ID, as stored in OpenSK, is a 112-entry Vec<u8> that starts with
/// a random 128-bit AES IV. This effectively takes the 128-bit AES IV and turns it into
@ -681,7 +793,11 @@ impl PersistentStore {
None, None::<fn()>
).ok() {
let mut data = Vec::<u8>::new();
acert.read_to_end(&mut data).or(Err(Ctap2StatusCode::CTAP2_ERR_VENDOR_INTERNAL_ERROR))?;
match acert.read_to_end(&mut data) {
Ok(l) => log::info!("read {} bytes", l),
Err(e) => log::error!("error reading certificate: {:?}", e),
}
log::info!("read back cert: {:x?}", data);
Ok(Some(data))
} else {
Ok(None)

View file

@ -32,6 +32,7 @@ impl TimedPermission {
// Checks if the timeout is not reached, false for differing ClockValue frequencies.
pub fn is_granted(&self, now: ClockValue) -> bool {
if let TimedPermission::Granted(timeout) = self {
log::info!("is_granted timeout: {}, now {}", timeout.ms(), now.ms());
if let Some(remaining_duration) = timeout.wrapping_sub(now) {
return remaining_duration > Duration::from_ms(0);
}
@ -43,6 +44,7 @@ impl TimedPermission {
// Returns a new state for differing ClockValue frequencies.
pub fn check_expiration(self, now: ClockValue) -> TimedPermission {
if let TimedPermission::Granted(timeout) = self {
log::info!("check_expiration timeout: {}, now {}", timeout.ms(), now.ms());
if let Some(remaining_duration) = timeout.wrapping_sub(now) {
if remaining_duration > Duration::from_ms(0) {
return TimedPermission::Granted(timeout);
@ -56,14 +58,6 @@ impl TimedPermission {
#[cfg(feature = "with_ctap1")]
#[derive(Debug)]
pub struct U2fUserPresenceState {
// If user presence was recently requested, its timeout is saved here.
needs_up: TimedPermission,
// Button touch timeouts, while user presence is requested, are saved here.
has_up: TimedPermission,
// This is the timeout duration of user presence requests.
request_duration: Duration<i64>,
// This is the timeout duration of button touches.
presence_duration: Duration<i64>,
}
#[cfg(feature = "with_ctap1")]
@ -72,45 +66,31 @@ impl U2fUserPresenceState {
request_duration: Duration<i64>,
presence_duration: Duration<i64>,
) -> U2fUserPresenceState {
crate::ux::set_durations(request_duration.ms(), presence_duration.ms());
U2fUserPresenceState {
needs_up: TimedPermission::Waiting,
has_up: TimedPermission::Waiting,
request_duration,
presence_duration,
}
}
// Granting user presence is ignored if it needs activation, but waits. Also cleans up.
pub fn grant_up(&mut self, now: ClockValue) {
self.check_expiration(now);
if self.needs_up.is_granted(now) {
self.needs_up = TimedPermission::Waiting;
self.has_up = TimedPermission::granted(now, self.presence_duration);
}
pub fn grant_up(&mut self, _now: ClockValue) {
// this is a NOP because it's handled by another thread
}
// This marks user presence as needed or uses it up if already granted. Also cleans up.
pub fn consume_up(&mut self, now: ClockValue) -> bool {
self.check_expiration(now);
if self.has_up.is_granted(now) {
self.has_up = TimedPermission::Waiting;
true
} else {
self.needs_up = TimedPermission::granted(now, self.request_duration);
false
}
pub fn consume_up(&mut self, _now: ClockValue, reason: String) -> bool {
crate::ux::request_permission_polling(String::from(reason))
}
// Returns if user presence was requested. Also cleans up.
pub fn is_up_needed(&mut self, now: ClockValue) -> bool {
self.check_expiration(now);
self.needs_up.is_granted(now)
pub fn is_up_needed(&mut self, _now: ClockValue) -> bool {
// this is not used by Xous
false
}
// If you don't regularly call any other function, not cleaning up leads to overflow problems.
pub fn check_expiration(&mut self, now: ClockValue) {
self.needs_up = self.needs_up.check_expiration(now);
self.has_up = self.has_up.check_expiration(now);
#[allow(dead_code)]
pub fn check_expiration(&mut self, _now: ClockValue) {
// not needed by Xous because we use an i64 for time
}
}
@ -120,7 +100,7 @@ mod test {
use super::*;
use core::isize;
const CLOCK_FREQUENCY_HZ: usize = 32768;
const CLOCK_FREQUENCY_HZ: usize = 1000;
const ZERO: ClockValue = ClockValue::new(0, CLOCK_FREQUENCY_HZ);
const BIG_POSITIVE: ClockValue = ClockValue::new(isize::MAX / 1000 - 1, CLOCK_FREQUENCY_HZ);
const NEGATIVE: ClockValue = ClockValue::new(-1, CLOCK_FREQUENCY_HZ);

View file

@ -1,6 +1,7 @@
#![cfg_attr(target_os = "none", no_std)]
#![cfg_attr(target_os = "none", no_main)]
mod ux;
mod repl;
use repl::*;
use num_traits::*;
@ -76,6 +77,7 @@ fn main() -> ! {
// let's try keeping this completely private as a server. can we do that?
let sid = xous::create_server().unwrap();
ux::start_ux_thread();
let _ = thread::spawn({
move || {
@ -89,6 +91,15 @@ fn main() -> ! {
let mut ctap_state = CtapState::new(&mut rng, check_user_presence, boot_time);
let mut ctap_hid = CtapHid::new();
loop {
let now = ClockValue::new(tt.elapsed_ms() as i64, 1000);
if /*button_touched.get()*/ false {
ctap_state.u2f_up_state.grant_up(now);
}
// These calls are making sure that even for long inactivity, wrapping clock values
// never randomly wink or grant user presence for U2F.
ctap_state.update_command_permission(now);
ctap_hid.wink_permission = ctap_hid.wink_permission.check_expiration(now);
match usb.u2f_wait_incoming() {
Ok(msg) => {
log::trace!("FIDO listener got message: {:?}", msg);
@ -113,6 +124,21 @@ fn main() -> ! {
log::warn!("FIDO listener got an error: {:?}", e);
}
}
let now = ClockValue::new(tt.elapsed_ms() as i64, 1000);
if ctap_hid.wink_permission.is_granted(now) {
log::info!("wink");
// wink_leds(led_counter);
} else {
if ctap_state.u2f_up_state.is_up_needed(now) {
// Flash the LEDs with an almost regular pattern. The inaccuracy comes from
// delay caused by processing and sending of packets.
log::info!("leds blink");
//blink_leds(led_counter);
} else {
log::info!("leds off");
//switch_off_leds();
}
}
}
}
});
@ -175,7 +201,7 @@ fn main() -> ! {
xous::terminate_process(0)
}
fn check_user_presence(cid: ChannelID) -> Result<(), Ctap2StatusCode> {
fn check_user_presence(_cid: ChannelID) -> Result<(), Ctap2StatusCode> {
log::warn!("check user presence called, but not implemented!");
Ok(())
}

View file

@ -4,7 +4,6 @@ use graphics_server::{Gid, Point, Rectangle, TextBounds, TextView, DrawStyle, Pi
use graphics_server::api::GlyphStyle;
use xous::MessageEnvelope;
use core::fmt::Write;
use locales::t;
#[allow(dead_code)]
pub(crate) struct Repl {

View file

@ -1,3 +1,4 @@
#![allow(dead_code)] // a fair bit of dead code here because we have adapters from Tock functions we don't use
// shims for Tock calls, to avoid having to recode some fairly pervasive patterns in OpenSK
use std::ops::{Sub, Add, AddAssign};

353
apps/vault/src/ux.rs Normal file
View file

@ -0,0 +1,353 @@
use std::thread;
use std::sync::{Arc, atomic::AtomicU32, atomic::Ordering};
use num_traits::*;
use xous::{msg_scalar_unpack, send_message, Message, msg_blocking_scalar_unpack};
use xous_ipc::Buffer;
use locales::t;
use crate::ctap::hid::{CtapHid, KeepaliveStatus};
use usbd_human_interface_device::device::fido::FidoMsg;
#[derive(Debug, rkyv::Archive, rkyv::Serialize, rkyv::Deserialize, Copy, Clone)]
pub(crate) struct FidoRequest {
pub channel_id: [u8; 4],
pub desc: xous_ipc::String::<1024>,
pub deferred: bool,
pub granted: bool,
}
#[derive(num_derive::FromPrimitive, num_derive::ToPrimitive, Debug)]
pub(crate) enum UxOp {
// sets the timeouts, and also resets and pending expirations or granted state
SetTimers,
RequestPermission,
Pump,
Quit
}
struct Timeouts {
/// how long after an interaction has happened that the interaction may still be deemed valid and "consumed"
pub presence_timeout_ms: i64,
/// how long the prompt should stay up before it is considered to be timed out
pub prompt_timeout_ms: i64,
}
#[derive(Eq, PartialEq, Debug)]
enum UxState {
Idle,
Prompt(i64),
Present(i64),
}
static SELF_CID: AtomicU32 = AtomicU32::new(0);
/*
/// This must be proceeded by a call to request permission, to set up the scenario
pub(crate) fn poll_consume_permission() -> bool {
if SELF_CID.load(Ordering::SeqCstg) == 0 {
log::error!("internal error: ux thread not started");
return false;
}
match send_message(SELF_CID.load(Ordering::SeqCst),
Message::new_blocking_scalar(UxOp::ConsumePermission.to_usize.unwrap(), 0, 0, 0, 0)
).expect("couldn't query ux thread") {
xous::Result::Scalar1(r) => {
if r == 1 {
true
} else {
false
}
}
_ => log::error!("Internal error: wrong return type"),
}
}*/
pub(crate) fn set_durations(prompt: i64, presence: i64) {
if SELF_CID.load(Ordering::SeqCst) == 0 {
log::error!("internal error: ux thread not started");
return;
}
// i mean, these really should never be bigger than this but...
assert!(presence <= usize::MAX as i64);
assert!(prompt <= usize::MAX as i64);
send_message(SELF_CID.load(Ordering::SeqCst),
Message::new_scalar(UxOp::SetTimers.to_usize().unwrap(),
presence as usize,
prompt as usize,
0,
0,
)
).expect("couldn't set timers");
}
pub(crate) fn request_permission_blocking(reason: String, channel_id: [u8; 4]) -> bool {
log::info!("requesting permission (blocking");
request_permission_inner(reason, channel_id, true)
}
pub(crate) fn request_permission_polling(reason: String) -> bool {
log::info!("requesting permission (polling)");
request_permission_inner(reason, [0xff, 0xff, 0xff, 0xff], false)
}
fn request_permission_inner(reason: String, channel_id: [u8; 4], blocking: bool) -> bool {
if SELF_CID.load(Ordering::SeqCst) == 0 {
log::error!("internal error: ux thread not started");
return false;
}
let fido_req = FidoRequest {
channel_id,
desc: xous_ipc::String::from_str(&reason),
deferred: blocking,
granted: false
};
let mut buf = Buffer::into_buf(fido_req).expect("couldn't do IPC transformation");
buf.lend_mut(
SELF_CID.load(Ordering::SeqCst),
UxOp::RequestPermission.to_u32().unwrap()
).expect("couldn't request permission");
let ret = buf.to_original::<FidoRequest, _>().expect("couldn't do IPC transformation");
ret.granted
}
const DEFAULT_PRESENCE_TIMEOUT_MS: i64 = 30_000;
const DEFAULT_PROMPT_TIMEOUT_MS: i64 = 10_000;
const POLLED_PROMPT_TIMEOUT_MS: i64 = 1000; // how long the screen stays up after the host "gives up" polling
const KEEPALIVE_MS: usize = 100;
pub(crate) fn start_ux_thread() {
let sid = xous::create_server().unwrap();
let cid = xous::connect(sid).expect("couldn't connect to UX thread server");
SELF_CID.store(cid, Ordering::SeqCst);
log::trace!("sid: {:?}, self CID: {}/{}", sid, cid, SELF_CID.load(Ordering::SeqCst));
let _ = thread::spawn({
let sid = sid.clone();
let self_cid = cid.clone();
move || {
let tt = ticktimer_server::Ticktimer::new().unwrap();
let mut timeouts = Timeouts {
presence_timeout_ms: DEFAULT_PRESENCE_TIMEOUT_MS,
prompt_timeout_ms: DEFAULT_PROMPT_TIMEOUT_MS,
};
let mut ux_state = UxState::Idle;
let mut request_str_base = String::new();
let xns = xous_names::XousNames::new().unwrap();
let modals = modals::Modals::new(&xns).unwrap();
let kbhit = Arc::new(AtomicU32::new(0));
let mut channel_id: [u8; 4] = [0xff, 0xff, 0xff, 0xff]; // this is the broadcast channel
let usb = usb_device_xous::UsbHid::new();
let mut deferred_req: Option::<xous::MessageEnvelope> = None;
let mut last_timer = 0;
loop {
let mut msg = xous::receive_message(sid).unwrap();
match FromPrimitive::from_usize(msg.body.id()) {
Some(UxOp::SetTimers) => msg_scalar_unpack!(msg, presence, prompt, _, _, {
timeouts = Timeouts {
presence_timeout_ms: presence as i64,
prompt_timeout_ms: prompt as i64,
};
ux_state = UxState::Idle;
// in case this is called while a deferred response is pending...deny the request
if let Some(mut msg) = deferred_req.take() {
let mut buffer = unsafe { Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap()) };
let mut fido_request = buffer.to_original::<FidoRequest, _>().unwrap();
fido_request.granted = false;
buffer.replace(fido_request).unwrap();
}
}),
/*
// this is a polled request, used by legacy u2f transactions
Some(UxOp::ConsumePermission) => msg_blocking_scalar_unpack!(msg, _, _, _, _, {
match ux_state {
UxState::Idle | UxState::Prompt(_) => {
// 0 = not present
xous::return_scalar(msg.sender, 0).unwrap();
},
UxState::Present(_) => {
// 1 = present
xous::return_scalar(msg.sender, 1).unwrap();
ux_state = UxState::Idle;
// these two paths shouldn't be mixed-and-matched, but let's just enforce that.
assert!(deferred_req.is_none(), "polled request succeeded when a blocking request was also in progress");
}
}
}), */
// this can set up either a blocking request (deferred = true), or a polled request (deferred = false)
// u2f polls; fido2 seems to require blocking requests. This difference causes a lot of complications.
Some(UxOp::RequestPermission) => {
let deferred = {
let buffer = unsafe { Buffer::from_memory_message(msg.body.memory_message().unwrap()) };
let fido_request = buffer.to_original::<FidoRequest, _>().unwrap();
channel_id = fido_request.channel_id;
request_str_base.clear();
request_str_base.push_str(fido_request.desc.as_str().unwrap_or("UTF8 Error"));
fido_request.deferred
};
if deferred {
match ux_state {
UxState::Idle => {}, // do the rest of the code
// I'm interpreting the OpenSK implementation to mean that once you have indicate your presence,
// you don't have to indicate it *again* for some duration interval, to avoid annoying the user.
// If it's the case that this is not true, then what should happen is when the original deferred request
// returns, the UxState immediately goes to Idle. This will trigger another pop-up the next time
// the call is made.
UxState::Present(_) => {
// short circuit all the logic, and grant the presence
let mut buffer = unsafe { Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap()) };
let mut fido_request = buffer.to_original::<FidoRequest, _>().unwrap();
fido_request.granted = true;
buffer.replace(fido_request).unwrap();
continue;
}
UxState::Prompt(_) => {
panic!("Illegal state -- the caller should have blocked on the Prompt state, making it impossible to double-initiate");
}
}
} else {
match ux_state {
UxState::Idle => log::info!("-->U2F SETUP<--"),
UxState::Present(_) => {
log::info!("-->U2F USER PRESENT<--");
let mut buffer = unsafe { Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap()) };
let mut fido_request = buffer.to_original::<FidoRequest, _>().unwrap();
fido_request.granted = true;
buffer.replace(fido_request).unwrap();
ux_state = UxState::Idle; // in the case of U2F, there is no persistence to the presence, it goes away immediately
continue;
}
UxState::Prompt(_) => {
log::info!("-->U2F WAITING<--");
let prompt_expiration_ms = (tt.elapsed_ms() as i64) + POLLED_PROMPT_TIMEOUT_MS;
ux_state = UxState::Prompt(prompt_expiration_ms); // extend the prompt time out
let mut buffer = unsafe { Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap()) };
let mut fido_request = buffer.to_original::<FidoRequest, _>().unwrap();
fido_request.granted = false;
buffer.replace(fido_request).unwrap();
// in case of U2F, just inform that no permission is granted yet and abort
continue;
}
}
}
let prompt_expiration_ms = (tt.elapsed_ms() as i64)
+ if deferred {
timeouts.prompt_timeout_ms
} else {
POLLED_PROMPT_TIMEOUT_MS
};
ux_state = UxState::Prompt(prompt_expiration_ms);
let mut request_str = String::from(&request_str_base);
if deferred {
last_timer = 1 + (prompt_expiration_ms - tt.elapsed_ms() as i64) / 1000;
request_str.push_str(
&format!("{}\n{}s remaining",
&request_str_base,
last_timer)
);
}
modals.dynamic_notification(
Some(t!("vault.u2freq", xous::LANG)),
Some(&request_str),
).unwrap();
kbhit.store(0, Ordering::SeqCst);
let _ = thread::spawn({
let token = modals.token().clone();
let conn = modals.conn().clone();
let kbhit = kbhit.clone();
move || {
// note that if no key is hit, we get None back on dialog box close automatically
match modals::dynamic_notification_blocking_listener(token, conn) {
Ok(Some(c)) => {
log::info!("kbhit got {}", c);
kbhit.store(c as u32, Ordering::SeqCst)
},
Ok(None) => {
log::info!("kbhit exited or had no characters");
kbhit.store(0, Ordering::SeqCst)
},
Err(e) => log::error!("error waiting for keyboard hit from blocking listener: {:?}", e),
}
}
});
send_message(self_cid,
Message::new_scalar(UxOp::Pump.to_usize().unwrap(), KEEPALIVE_MS, 0, 0, 0)
).unwrap();
if deferred {
deferred_req = Some(msg);
} else { // in the case of a polled implementation, just return false for granted and move on
let mut buffer = unsafe { Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap()) };
let mut fido_request = buffer.to_original::<FidoRequest, _>().unwrap();
fido_request.granted = false;
buffer.replace(fido_request).unwrap();
}
}
Some(UxOp::Pump) => msg_scalar_unpack!(msg, interval, _, _, _, {
match ux_state {
UxState::Idle => {
// don't issue another pump message, causing the loop to end
},
UxState::Present(present_expiration_ms) => {
if let Some(mut msg) = deferred_req.take() {
let mut buffer = unsafe { Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap()) };
let mut fido_request = buffer.to_original::<FidoRequest, _>().unwrap();
fido_request.granted = true;
buffer.replace(fido_request).unwrap();
}
// check if we timed out
if tt.elapsed_ms() as i64 >= present_expiration_ms {
ux_state = UxState::Idle;
} else { // else pump the loop again
send_message(self_cid,
Message::new_scalar(UxOp::Pump.to_usize().unwrap(), KEEPALIVE_MS, 0, 0, 0)
).unwrap();
}
},
UxState::Prompt(prompt_expiration_ms) => {
if deferred_req.is_some() { // keepalives are only needed for deferred requests
let keepalive_msg = CtapHid::keepalive(channel_id, KeepaliveStatus::UpNeeded);
for pkt in keepalive_msg {
let mut ka = FidoMsg::default();
ka.packet.copy_from_slice(&pkt);
let status = usb.u2f_send(ka);
match status {
Ok(()) => (),
Err(e) => log::error!("Error sending keepalive: {:?}", e),
}
}
let new_timer = 1 + (prompt_expiration_ms - tt.elapsed_ms() as i64) / 1000;
if last_timer != new_timer {
let mut request_str = String::from(&request_str_base);
request_str.push_str(
&format!("{}\n{}s remaining",
&request_str_base,
new_timer)
);
modals.dynamic_notification_update(
None,
Some(&request_str),
).unwrap();
last_timer = new_timer;
}
}
// check if we got a hit
if kbhit.load(Ordering::SeqCst) != 0 {
ux_state = UxState::Present(tt.elapsed_ms() as i64 + timeouts.presence_timeout_ms);
send_message(self_cid,
Message::new_scalar(UxOp::Pump.to_usize().unwrap(), KEEPALIVE_MS, 0, 0, 0)
).unwrap();
} else {
tt.sleep_ms(interval).unwrap();
// check if we timed out
if tt.elapsed_ms() as i64 >= prompt_expiration_ms {
ux_state = UxState::Idle;
modals.dynamic_notification_close().unwrap();
} else { // else pump the loop again
send_message(self_cid,
Message::new_scalar(UxOp::Pump.to_usize().unwrap(), KEEPALIVE_MS, 0, 0, 0)
).unwrap();
}
}
}
}
}),
Some(UxOp::Quit) => {
break;
}
None => {
log::error!("got unknown message: {:?}", msg);
}
}
}
}
});
}

196
apps/vault/tools/configure.py Executable file
View file

@ -0,0 +1,196 @@
#!/usr/bin/env python3
# Copyright 2020 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# Lint as: python3
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import argparse
import getpass
import datetime
import sys
import uuid
import colorama
from tqdm.auto import tqdm
from cryptography import x509
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.primitives.asymmetric import ec
from fido2 import ctap
from fido2 import ctap2
from fido2 import hid
OPENSK_VID_PID = (0x1209, 0x0001)
OPENSK_VENDOR_CONFIGURE = 0x40
def fatal(msg):
tqdm.write(f"{colorama.Fore.RED + colorama.Style.BRIGHT}fatal:"
f"{colorama.Style.RESET_ALL} {msg}")
sys.exit(1)
def error(msg):
tqdm.write(f"{colorama.Fore.RED}error:{colorama.Style.RESET_ALL} {msg}")
def info(msg):
tqdm.write(f"{colorama.Fore.GREEN + colorama.Style.BRIGHT}info:"
f"{colorama.Style.RESET_ALL} {msg}")
def get_opensk_devices(batch_mode):
devices = []
for dev in hid.CtapHidDevice.list_devices():
if (dev.descriptor.vid, dev.descriptor.pid) == OPENSK_VID_PID:
if dev.capabilities & hid.CAPABILITY.CBOR:
if batch_mode:
devices.append(ctap2.CTAP2(dev))
else:
return [ctap2.CTAP2(dev)]
return devices
def get_private_key(data, password=None):
# First we try without password.
try:
return serialization.load_pem_private_key(data, password=None)
except TypeError:
# Maybe we need a password then.
if sys.stdin.isatty():
password = getpass.getpass(prompt="Private key password: ")
else:
password = sys.stdin.readline().rstrip()
return get_private_key(data, password=password.encode(sys.stdin.encoding))
def main(args):
colorama.init()
# We need either both the certificate and the key or none
if bool(args.priv_key) ^ bool(args.certificate):
fatal("Certificate and private key must be set together or both omitted.")
cbor_data = {1: args.lock}
if args.priv_key:
cbor_data[1] = args.lock
priv_key = get_private_key(args.priv_key.read())
if not isinstance(priv_key, ec.EllipticCurvePrivateKey):
fatal("Private key must be an Elliptic Curve one.")
if not isinstance(priv_key.curve, ec.SECP256R1):
fatal("Private key must use Secp256r1 curve.")
if priv_key.key_size != 256:
fatal("Private key must be 256 bits long.")
info("Private key is valid.")
cert = x509.load_pem_x509_certificate(args.certificate.read())
# Some sanity/validity checks
now = datetime.datetime.utcnow()
if cert.not_valid_before > now:
fatal("Certificate validity starts in the future.")
if cert.not_valid_after <= now:
fatal("Certificate expired.")
pub_key = cert.public_key()
if not isinstance(pub_key, ec.EllipticCurvePublicKey):
fatal("Certificate public key must be an Elliptic Curve one.")
if not isinstance(pub_key.curve, ec.SECP256R1):
fatal("Certificate public key must use Secp256r1 curve.")
if pub_key.key_size != 256:
fatal("Certificate public key must be 256 bits long.")
if pub_key.public_numbers() != priv_key.public_key().public_numbers():
fatal("Certificate public doesn't match with the private key.")
info("Certificate is valid.")
cbor_data[2] = {
1:
cert.public_bytes(serialization.Encoding.DER),
2:
priv_key.private_numbers().private_value.to_bytes(
length=32, byteorder='big', signed=False)
}
for authenticator in tqdm(get_opensk_devices(args.batch)):
# If the device supports it, wink to show which device
# we're going to program.
if authenticator.device.capabilities & hid.CAPABILITY.WINK:
authenticator.device.wink()
aaguid = uuid.UUID(bytes=authenticator.get_info().aaguid)
info(f"Programming OpenSK device AAGUID {aaguid} ({authenticator.device}).")
info("Please touch the device to confirm...")
try:
result = authenticator.send_cbor(
OPENSK_VENDOR_CONFIGURE,
data=cbor_data,
)
info(f"Certificate: {'Present' if result[1] else 'Missing'}")
info(f"Private Key: {'Present' if result[2] else 'Missing'}")
if args.lock:
info("Device is now locked down!")
except ctap.CtapError as ex:
if ex.code.value == ctap.CtapError.ERR.INVALID_COMMAND:
error("Failed to configure OpenSK (unsupported command).")
elif ex.code.value == 0xF2: # VENDOR_INTERNAL_ERROR
error(("Failed to configure OpenSK (lockdown conditions not met "
"or hardware error)."))
elif ex.code.value == ctap.CtapError.ERR.INVALID_PARAMETER:
error(
("Failed to configure OpenSK (device is partially programmed but "
"the given cert/key don't match the ones currently programmed)."))
else:
error(f"Failed to configure OpenSK (unknown error: {ex}")
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument(
"--batch",
default=False,
action="store_true",
help=(
"When batch processing is used, all plugged OpenSK devices will "
"be programmed the same way. Otherwise (default) only the first seen "
"device will be programmed."),
)
parser.add_argument(
"--certificate",
type=argparse.FileType("rb"),
default=None,
metavar="PEM_FILE",
dest="certificate",
help=("PEM file containing the certificate to inject into "
"the OpenSK authenticator."),
)
parser.add_argument(
"--private-key",
type=argparse.FileType("rb"),
default=None,
metavar="PEM_FILE",
dest="priv_key",
help=("PEM file containing the private key associated "
"with the certificate."),
)
parser.add_argument(
"--lock-device",
default=False,
action="store_true",
dest="lock",
help=("Locks the device (i.e. bootloader and JTAG access). "
"This command can fail if the certificate or the private key "
"haven't been both programmed yet."),
)
main(parser.parse_args())

View file

@ -0,0 +1,97 @@
#!/bin/bash
# Copyright 2019 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
generate_crypto_materials () {
# OpenSK AAGUID
local aaguid_file=crypto_data/aaguid.txt
# Root CA key pair and certificate
local ca_priv_key=crypto_data/opensk_ca.key
local ca_cert_name=crypto_data/opensk_ca
# Attestation key pair and certificate that will be embedded into the
# firmware. The certificate will be signed by the Root CA.
local opensk_key=crypto_data/opensk.key
local opensk_cert_name=crypto_data/opensk_cert
# Allow invoker to override the command with a full path.
local openssl=${OPENSSL:-$(which openssl)}
# We need openssl command to continue
if [ ! -x "${openssl}" ]
then
echo "Missing openssl command. Try to specify its full path using OPENSSL environment variable."
exit 1
fi
# Exit on first error
set -e
force_generate="$1"
mkdir -p crypto_data
if [ ! -f "${ca_priv_key}" ]
then
"${openssl}" ecparam -genkey -name prime256v1 -out "${ca_priv_key}"
fi
if [ ! -f "${ca_cert_name}.pem" ]
then
"${openssl}" req \
-new \
-key "${ca_priv_key}" \
-out "${ca_cert_name}.csr" \
-subj "/CN=OpenSK CA"
"${openssl}" x509 \
-trustout \
-req \
-days 7305 \
-in "${ca_cert_name}.csr" \
-signkey "${ca_priv_key}" \
-outform pem \
-out "${ca_cert_name}.pem" \
-sha256
fi
if [ "${force_generate}" = "Y" -o ! -f "${opensk_key}" ]
then
"${openssl}" ecparam -genkey -name prime256v1 -out "${opensk_key}"
fi
if [ "${force_generate}" = "Y" -o ! -f "${opensk_cert_name}.pem" ]
then
"${openssl}" req \
-new \
-key "${opensk_key}" \
-out "${opensk_cert_name}.csr" \
-subj "/CN=OpenSK Hacker Edition"
"${openssl}" x509 \
-req \
-days 3652 \
-in "${opensk_cert_name}.csr" \
-CA "${ca_cert_name}.pem" \
-CAkey "${ca_priv_key}" \
-CAcreateserial \
-outform pem \
-out "${opensk_cert_name}.pem" \
-sha256
fi
if [ "${force_generate}" = "Y" -o ! -f "${aaguid_file}" ]
then
uuidgen > "${aaguid_file}"
fi
}
generate_crypto_materials "$1"

View file

@ -410,36 +410,6 @@ impl Modals {
self.unlock();
Ok(())
}
/// If a dynamic notification is active, this will block and return only if one of two
/// conditions are met:
/// 1. a key is pressed, in which case, the `Some(char)` is the key pressed. If there is a
/// "fat finger" event, only the first character is reported.
/// 2. the dynamic notification is closed, in which case a `None` is reported.
pub fn dynamic_notification_blocking_listener(&self) -> Result<Option<char>, xous::Error> {
match send_message(
self.conn,
Message::new_blocking_scalar(
Opcode::ListenToDynamicNotification.to_usize().unwrap(),
self.token[0] as usize,
self.token[1] as usize,
self.token[2] as usize,
self.token[3] as usize,
),
).expect("couldn't listen") {
xous::Result::Scalar2(is_some, code) => {
if is_some == 1 {
let c = char::from_u32(code as u32).unwrap_or('\u{0000}');
Ok(Some(c))
} else if is_some == 2 {
log::warn!("Attempt to listen, but did not have the mutex. Aborted.");
Ok(None)
} else {
Ok(None)
}
}
_ => Err(xous::Error::InternalError)
}
}
/// Blocks until we have a lock on the modals server
fn lock(&self) {
@ -471,6 +441,10 @@ impl Modals {
fn unlock(&self) {
self.have_lock.set(false);
}
pub fn conn(&self) -> CID {self.conn}
/// Don't leak this token outside of your server, otherwise, another server can pretend to be you and
/// steal your modal information!
pub fn token(&self) -> [u32; 4] {self.token}
}
use core::sync::atomic::{AtomicU32, Ordering};
@ -489,3 +463,37 @@ impl Drop for Modals {
// de-allocate those items here. They don't need a reference count because they are object-specific
}
}
/// If a dynamic notification is active, this will block and return only if one of two
/// conditions are met:
/// 1. a key is pressed, in which case, the `Some(char)` is the key pressed. If there is a
/// "fat finger" event, only the first character is reported.
/// 2. the dynamic notification is closed, in which case a `None` is reported.
///
/// This function is "broken out" so that it can be called from a thread without having
/// to wrap a mutex around the primary Modals structure.
pub fn dynamic_notification_blocking_listener(token: [u32; 4], conn: CID) -> Result<Option<char>, xous::Error> {
match send_message(
conn,
Message::new_blocking_scalar(
Opcode::ListenToDynamicNotification.to_usize().unwrap(),
token[0] as usize,
token[1] as usize,
token[2] as usize,
token[3] as usize,
),
).expect("couldn't listen") {
xous::Result::Scalar2(is_some, code) => {
if is_some == 1 {
let c = char::from_u32(code as u32).unwrap_or('\u{0000}');
Ok(Some(c))
} else if is_some == 2 {
log::warn!("Attempt to listen, but did not have the mutex. Aborted.");
Ok(None)
} else {
Ok(None)
}
}
_ => Err(xous::Error::InternalError)
}
}

View file

@ -536,7 +536,7 @@ fn main() -> ! {
renderer_cid,
Opcode::HandleDynamicNotificationKeyhit.to_u32().unwrap(),
);
gutter.set_manual_dismiss(false);
gutter.set_manual_dismiss(true);
renderer_modal.modify(
Some(ActionType::Notification(gutter)),
Some(&top_text),
@ -599,6 +599,7 @@ fn main() -> ! {
token_lock = next_lock(&mut work_queue);
},
Some(Opcode::HandleDynamicNotificationKeyhit) => msg_scalar_unpack!(msg, k, _, _, _, {
log::info!("Dynamic kbd hit: {}({})", k, char::from_u32(k as u32).unwrap_or(' '));
if let Some(sender) = dynamic_notification_listener.take() {
xous::return_scalar2(sender, 1, k).unwrap();
}

View file

@ -113,7 +113,11 @@ impl<'a> Read for PddbKey<'a> {
}
PddbRetcode::BasisLost => Err(Error::new(ErrorKind::BrokenPipe, "Basis lost")),
PddbRetcode::AccessDenied => Err(Error::new(ErrorKind::PermissionDenied, "Access denied")),
_ => Err(Error::new(ErrorKind::Other, "Unhandled error code in PddbKey Read")),
PddbRetcode::UnexpectedEof => Ok(0), // I believe this is the "expected" behavior for reads that want to read beyond the current end of file
_ => {
log::error!("Unhandled error code: {:?}", pbuf.retcode);
Err(Error::new(ErrorKind::Other, "Unhandled error code in PddbKey Read"))
},
}
}
}
@ -158,7 +162,7 @@ impl<'a> Write for PddbKey<'a> {
}
PddbRetcode::BasisLost => Err(Error::new(ErrorKind::BrokenPipe, "Basis lost")),
PddbRetcode::AccessDenied => Err(Error::new(ErrorKind::PermissionDenied, "Access denied")),
_ => Err(Error::new(ErrorKind::Other, "Unhandled error code in PddbKey Read")),
_ => Err(Error::new(ErrorKind::Other, "Unhandled error code in PddbKey Write")),
}
}
}