examples-features/ctap.rs - 3p/tock/libtock-rs - Git at Google

 //! This is a featured CTAP example
 //! WARNING! This currently uses unsound crypto operations
 //! This is only a demo and should not be used in real enviroments
 #![no_std]
 #![feature(alloc_error_handler)]

 extern crate alloc;

 use core::alloc::Layout;
 use core::cell::Cell;
 use core::convert::TryInto;
 use core::fmt::{self, Debug, Error, Formatter};
 use core::time::Duration;
 use ctap2_authenticator::credentials::{RpCredential, UserCredential};
 use ctap2_authenticator::usbhid::{
     CtapHidCapabilities, CtapHidPlatform, KeepaliveResponse, TransactionProcessor,
 };
 use ctap2_authenticator::Authenticator;
 use ctap2_authenticator::{
     AuthenticatorPlatform, CredentialDescriptorList, CtapOptions, PublicKey, Signature,
 };
 use generic_array::GenericArray;
 use libtock::ctap::{CtapRecvBuffer, CtapSendBuffer};
 use libtock::hmac::{HmacDataBuffer, HmacDestBuffer, HmacDriverFactory, HmacKeyBuffer};
 use libtock::println;
 use libtock::result::TockResult;
 use libtock::syscalls;
 use p256::ecdsa::{signature::Signer, SigningKey};
 use p256::elliptic_curve::ff::PrimeField;
 use p256::{Scalar, SecretKey};
 use subtle::{Choice, ConditionallySelectable};

 libtock_core::stack_size! {0x4000}

 #[derive(Debug, Clone, PartialEq, Eq, Copy)]
 pub struct PrivateKey(Scalar);

 impl ConditionallySelectable for PrivateKey {
     fn conditional_select(a: &Self, b: &Self, choice: Choice) -> Self {
         Self(ConditionallySelectable::conditional_select(
             &a.0, &b.0, choice,
         ))
     }
 }

 impl Default for PrivateKey {
     fn default() -> Self {
         Self(Scalar::default())
     }
 }

 impl PrivateKey {
     pub fn from_bytes(bytes: &[u8; 32]) -> Option<Self> {
         Scalar::from_repr(GenericArray::clone_from_slice(bytes)).map(|s| Self(s))
     }
 }

 /// This is the provided implementation of `CtapHidPlatform` to be used in the `UsbContext`
 pub(crate) struct UsbKeyHidPlatform {}

 impl UsbKeyHidPlatform {
     pub fn new() -> Self {
         Self {}
     }
 }

 impl CtapHidPlatform for UsbKeyHidPlatform {
     // Should be kept in sync with the Crates version if possible
     const MAJOR_VERSION: u8 = 0;
     const MINOR_VERSION: u8 = 0;
     const BUILD_VERSION: u8 = 0;
     const CAPABILITIES: CtapHidCapabilities = CtapHidCapabilities {
         wink: true,
         cbor: true,
         msg: false,
     };

     fn wink(&mut self) {}

     fn cancel(&mut self) {
         println!("cancel");
         unimplemented!()
     }

     fn keepalive_needed(&mut self) -> KeepaliveResponse {
         println!("keepalive_needed");
         unimplemented!()
     }

     fn start_timer(&mut self) {
         println!("start_timer");
     }

     fn has_timed_out(&mut self) -> bool {
         println!("has_timed_out");
         false
     }
 }

 #[derive(Clone, Copy)]
 pub struct HmacKeyCredential(pub(crate) [u8; 40]);

 impl HmacKeyCredential {
     fn new(mac: &[u8; 32], nonce: [u8; 8]) -> Self {
         let mut new = [0; 40];
         new[..32].copy_from_slice(&mac[..]);
         new[32..].copy_from_slice(&nonce[..]);
         Self(new)
     }

     fn get_mac(&self) -> [u8; 32] {
         let mut mac = [0; 32];
         mac.copy_from_slice(&self.0[..32]);
         mac
     }
 }

 impl AsRef<[u8]> for HmacKeyCredential {
     fn as_ref(&self) -> &[u8] {
         &self.0
     }
 }

 impl Debug for HmacKeyCredential {
     fn fmt(&self, f: &mut Formatter) -> Result<(), Error> {
         write!(
             f,
             "HmacKeyCredential {{ mac: {:?}, nonce: {:?} }}",
             &self.0[..32],
             &self.0[32..]
         )
     }
 }

 impl PartialEq for HmacKeyCredential {
     fn eq(&self, other: &Self) -> bool {
         self.0[..] == other.0[..]
     }
 }

 impl Eq for HmacKeyCredential {}

 const ITERATOR_MAX_LENGTH: usize = 8;

 pub struct HmacCredentialQueue {
     index: usize,
     length: usize,
     list: [Option<(HmacKeyCredential, u32)>; ITERATOR_MAX_LENGTH],
 }

 impl HmacCredentialQueue {
     pub(crate) fn new() -> Self {
         Self {
             index: 0,
             length: 0,
             list: [None; ITERATOR_MAX_LENGTH],
         }
     }

     pub(crate) fn push(&mut self, credential: HmacKeyCredential, counter: u32) -> Result<(), ()> {
         if self.length < ITERATOR_MAX_LENGTH {
             self.list[self.length] = Some((credential, counter));
             self.length += 1;
             Ok(())
         } else {
             Err(())
         }
     }

     pub(crate) fn len(&self) -> usize {
         self.length
     }
 }

 impl Iterator for HmacCredentialQueue {
     type Item = (HmacKeyCredential, u32);

     fn next(&mut self) -> Option<Self::Item> {
         if self.list[self.index].is_some() {
             self.index += 1;
             self.list[self.index - 1]
         } else {
             None
         }
     }
 }

 pub(crate) struct CtapPlatform {
     hmac: HmacDriverFactory,
 }

 impl CtapPlatform {
     fn new(hmac: HmacDriverFactory) -> Self {
         Self { hmac }
     }
 }

 impl fmt::Debug for CtapPlatform {
     fn fmt(&self, _f: &mut fmt::Formatter<'_>) -> fmt::Result {
         Ok(())
     }
 }

 impl CtapPlatform {
     fn generate_key_seed(
         &mut self,
         rp_id: &str,
         nonce: &[u8; 8],
     ) -> [u8; libtock::hmac::DEST_BUFFER_SIZE] {
         let hmac_driver;
         match self.hmac.init_driver() {
             Err(_) => {
                 panic!("Hmac init error");
             }
             Ok(driver) => {
                 hmac_driver = driver;
             }
         }

         let mut key_buffer = HmacKeyBuffer::default();
         for (i, d) in rp_id.as_bytes().iter().enumerate() {
             key_buffer[i] = *d;
         }
         // We need to make sure this isn't dropped straight away
         let key_buffer_ret = hmac_driver.init_key_buffer(&mut key_buffer);
         if key_buffer_ret.is_err() {
             panic!("Hmac key buffer init error");
         }

         let mut data_buffer = HmacDataBuffer::default();
         for (i, d) in nonce.iter().enumerate() {
             data_buffer[i] = *d;
         }
         // We need to make sure this isn't dropped straight away
         let data_buffer_ret = hmac_driver.init_data_buffer(&mut data_buffer);
         if data_buffer_ret.is_err() {
             panic!("Hmac data buffer init error");
         }

         let mut dest_buffer = HmacDestBuffer::default();
         let seed_buffer;
         match hmac_driver.init_dest_buffer(&mut dest_buffer) {
             Err(_) => {
                 panic!("Hmac subscribe error");
             }
             Ok(buffer) => {
                 seed_buffer = buffer;
             }
         }

         let mut callback = |_result, _digest| {};

         // We need to make sure this isn't dropped straight away
         let subscribe = hmac_driver.subscribe(&mut callback);
         if subscribe.is_err() {
             panic!("Hmac subscribe error");
         }

         if hmac_driver.run().is_err() {
             panic!("Hmac run error");
         }

         // Yield waiting for the HMAC callback
         unsafe {
             syscalls::raw::yieldk();
         }

         let mut temp_buffer = [0; libtock::hmac::DEST_BUFFER_SIZE];
         seed_buffer.read_bytes(&mut temp_buffer[..]);
         temp_buffer
     }

     /// Generates a Credential from a CredentialId and checks that the Id is valid
     fn checked_generate_hmac_cred(
         &mut self,
         rp_id: &str,
         credential_id: &[u8],
     ) -> Option<HmacKeyCredential> {
         if credential_id.len() != 40 {
             return None;
         }

         let received_mac = &credential_id[..32];

         let seed_buffer = self.generate_key_seed(rp_id, &credential_id[32..40].try_into().unwrap());

         let credential =
             HmacKeyCredential::new(&seed_buffer, credential_id[32..].try_into().unwrap());

         let generated_mac = &credential.0[..32];

         if generated_mac == received_mac {
             Some(credential)
         } else {
             None
         }
     }
 }

 impl AuthenticatorPlatform for CtapPlatform {
     const AAGUID: [u8; 16] = [
         0xf8, 0xa0, 0x11, 0xf3, 0x8c, 0x0a, 0x4d, 0x15, 0x80, 0x06, 0x17, 0x11, 0x1f, 0x9e, 0xdc,
         0x7d,
     ];
     const CERTIFICATE: Option<&'static [u8]> = None;
     const MAX_MSG_LENGTH: u16 = 7609;
     const SUPPORTED_OPTIONS: CtapOptions = CtapOptions {
         plat: None,
         rk: Some(true),
         client_pin: None,
         up: Some(true),
         uv: Some(false),
     };
     type CredentialId = HmacKeyCredential;
     type PublicKeyBuffer = [u8; 32];
     type SignatureBuffer = [u8; 32];
     type CredentialIterator = HmacCredentialQueue;

     fn reset(&mut self) -> Result<(), ()> {
         println!("reset");
         unimplemented!()
     }

     fn check_exclude_list(&mut self, _rp_id: &str, _list: CredentialDescriptorList) -> bool {
         println!("check_exclude_list");
         unimplemented!()
     }

     fn locate_credentials(
         &mut self,
         rp_id: &str,
         list: Option<CredentialDescriptorList>,
     ) -> (u16, Self::CredentialIterator) {
         match list {
             None => (0, HmacCredentialQueue::new()),
             Some(list) => {
                 let mut result = HmacCredentialQueue::new();

                 for descriptor in list {
                     match self.checked_generate_hmac_cred(rp_id, descriptor.get_id()) {
                         None => (),
                         Some(credential) => {
                             match result.push(credential, 0) {
                                 Ok(()) => (),
                                 // NOTE: We just truncate if we don't have enough space to store all
                                 // fitting credentials
                                 Err(()) => break,
                             }
                         }
                     }
                 }

                 (result.len() as u16, result)
             }
         }
     }

     fn create_credential(
         &mut self,
         rp: RpCredential<&[u8], &str>,
         _user: UserCredential<&[u8], &str>,
     ) -> (Self::CredentialId, PublicKey<Self::PublicKeyBuffer>, u32) {
         println!("create_credential");
         let rp_id = core::str::from_utf8(rp.rp_id()).unwrap();
         // This nonce is static!!!!
         // This is really bad cryptowise, let's print a warning
         // TODO: Convert this to generate a nonce from Tock's TRNG
         println!("WARNING!!! The nonce is static, this key is insecure");
         println!("WARNING!!! Do not use this anywhere important");
         let nonce = [0; 8];

         let seed_buffer = self.generate_key_seed(rp_id, &nonce);

         let credential = HmacKeyCredential::new(&seed_buffer, nonce.try_into().unwrap());

         let secret_key = SecretKey::from_bytes(&seed_buffer[0..32]).unwrap();

         let pub_key = p256::EncodedPoint::from_secret_key(&secret_key, false);

         let x: [u8; 32] = pub_key.as_bytes()[1..33].try_into().unwrap();
         let y: [u8; 32] = pub_key.as_bytes()[33..].try_into().unwrap();

         let ret_key = PublicKey::nistp256(x, y);

         (credential, ret_key, 0)
     }

     fn attest(
         &mut self,
         id: &Self::CredentialId,
         data: &[u8],
     ) -> Option<Signature<Self::SignatureBuffer>> {
         // TODO: Should attest be different then sign?
         let attest = {
             let secret_key = SecretKey::from_bytes(id.get_mac()).unwrap();

             let signer = SigningKey::from(&secret_key);

             let sig = signer.sign(data);

             let mut r: [u8; 32] = [0; 32];
             r.clone_from_slice(&sig.r().as_ref().to_bytes());
             let mut s: [u8; 32] = [0; 32];
             s.clone_from_slice(&sig.s().as_ref().to_bytes());

             Signature::nistp256(r, s)
         };

         Some(attest)
     }

     fn sign(
         &mut self,
         id: &Self::CredentialId,
         data: &[u8],
     ) -> Option<Signature<Self::SignatureBuffer>> {
         let attest = {
             let secret_key = SecretKey::from_bytes(id.get_mac()).unwrap();
             let signer = SigningKey::from(&secret_key);
             let sig = signer.sign(data);

             let mut r: [u8; 32] = [0; 32];
             r.clone_from_slice(&sig.r().as_ref().to_bytes());
             let mut s: [u8; 32] = [0; 32];
             s.clone_from_slice(&sig.s().as_ref().to_bytes());

             Signature::nistp256(r, s)
         };

         Some(attest)
     }

     fn start_timeout(&mut self) {
         println!("start_timeout");
         unimplemented!()
     }

     fn has_timed_out(&mut self, _time: Duration) -> bool {
         println!("has_timed_out");
         unimplemented!()
     }
 }

 #[alloc_error_handler]
 unsafe fn alloc_error_handler(_: Layout) -> ! {
     println!("alloc_error_handler called");
     loop {
         syscalls::raw::yieldk();
     }
 }

 #[libtock::main]
 async fn main() -> TockResult<()> {
     let mut tp: Cell<TransactionProcessor<&'static mut [u8], UsbKeyHidPlatform>>;
     let mut temp_buffer = [0; libtock::ctap::RECV_BUFFER_SIZE];
     let mut drivers = libtock::retrieve_drivers()?;
     drivers.console.create_console();

     println!("Starting CTAP feature example");

     let ctap_driver = drivers.ctap.init_driver()?;

     let mut recv_buffer = CtapRecvBuffer::default();
     let recv_buffer = ctap_driver.init_recv_buffer(&mut recv_buffer)?;

     let mut send_buffer = CtapSendBuffer::default();
     let mut send_buffer = ctap_driver.init_send_buffer(&mut send_buffer)?;

     static mut BUFFER: &'static mut [u8] = &mut [0; 2048];
     unsafe {
         tp = Cell::new(TransactionProcessor::new(BUFFER, UsbKeyHidPlatform::new()));
     }

     let mut authenticator = Authenticator::create(CtapPlatform::new(drivers.hmac));

     let mut callback = |sent, _| {
         let mut looping = true;
         recv_buffer.read_bytes(&mut temp_buffer[..]);

         let temp_tp = tp.get_mut();
         let mut poll_msg = if sent == 0 { Some(&temp_buffer) } else { None };

         while looping {
             looping = false;
             let (maybe_request, maybe_data) = temp_tp.poll(poll_msg);

             if let Some(request) = maybe_request {
                 let response = authenticator.process(request);
                 temp_tp.response(response);
                 looping = true;
             }

             if let Some(mut data) = maybe_data {
                 send_buffer.write_bytes(&mut data[0..]);
                 let _ = ctap_driver.send_data();
             }

             poll_msg = None;
         }
         let _ = ctap_driver.allow_receive();
     };

     let _subscription = ctap_driver.subscribe(&mut callback)?;
     ctap_driver.allow_receive()?;

     loop {
         unsafe { syscalls::raw::yieldk() };
     }
 }
	//! This is a featured CTAP example
	//! WARNING! This currently uses unsound crypto operations
	//! This is only a demo and should not be used in real enviroments
	#![no_std]
	#![feature(alloc_error_handler)]

	extern crate alloc;

	use core::alloc::Layout;
	use core::cell::Cell;
	use core::convert::TryInto;
	use core::fmt::{self, Debug, Error, Formatter};
	use core::time::Duration;
	use ctap2_authenticator::credentials::{RpCredential, UserCredential};
	use ctap2_authenticator::usbhid::{
	CtapHidCapabilities, CtapHidPlatform, KeepaliveResponse, TransactionProcessor,
	};
	use ctap2_authenticator::Authenticator;
	use ctap2_authenticator::{
	AuthenticatorPlatform, CredentialDescriptorList, CtapOptions, PublicKey, Signature,
	};
	use generic_array::GenericArray;
	use libtock::ctap::{CtapRecvBuffer, CtapSendBuffer};
	use libtock::hmac::{HmacDataBuffer, HmacDestBuffer, HmacDriverFactory, HmacKeyBuffer};
	use libtock::println;
	use libtock::result::TockResult;
	use libtock::syscalls;
	use p256::ecdsa::{signature::Signer, SigningKey};
	use p256::elliptic_curve::ff::PrimeField;
	use p256::{Scalar, SecretKey};
	use subtle::{Choice, ConditionallySelectable};

	libtock_core::stack_size! {0x4000}

	#[derive(Debug, Clone, PartialEq, Eq, Copy)]
	pub struct PrivateKey(Scalar);

	impl ConditionallySelectable for PrivateKey {
	fn conditional_select(a: &Self, b: &Self, choice: Choice) -> Self {
	Self(ConditionallySelectable::conditional_select(
	&a.0, &b.0, choice,
	))
	}
	}

	impl Default for PrivateKey {
	fn default() -> Self {
	Self(Scalar::default())
	}
	}

	impl PrivateKey {
	pub fn from_bytes(bytes: &[u8; 32]) -> Option<Self> {
	Scalar::from_repr(GenericArray::clone_from_slice(bytes)).map(\|s\| Self(s))
	}
	}

	/// This is the provided implementation of `CtapHidPlatform` to be used in the `UsbContext`
	pub(crate) struct UsbKeyHidPlatform {}

	impl UsbKeyHidPlatform {
	pub fn new() -> Self {
	Self {}
	}
	}

	impl CtapHidPlatform for UsbKeyHidPlatform {
	// Should be kept in sync with the Crates version if possible
	const MAJOR_VERSION: u8 = 0;
	const MINOR_VERSION: u8 = 0;
	const BUILD_VERSION: u8 = 0;
	const CAPABILITIES: CtapHidCapabilities = CtapHidCapabilities {
	wink: true,
	cbor: true,
	msg: false,
	};

	fn wink(&mut self) {}

	fn cancel(&mut self) {
	println!("cancel");
	unimplemented!()
	}

	fn keepalive_needed(&mut self) -> KeepaliveResponse {
	println!("keepalive_needed");
	unimplemented!()
	}

	fn start_timer(&mut self) {
	println!("start_timer");
	}

	fn has_timed_out(&mut self) -> bool {
	println!("has_timed_out");
	false
	}
	}

	#[derive(Clone, Copy)]
	pub struct HmacKeyCredential(pub(crate) [u8; 40]);

	impl HmacKeyCredential {
	fn new(mac: &[u8; 32], nonce: [u8; 8]) -> Self {
	let mut new = [0; 40];
	new[..32].copy_from_slice(&mac[..]);
	new[32..].copy_from_slice(&nonce[..]);
	Self(new)
	}

	fn get_mac(&self) -> [u8; 32] {
	let mut mac = [0; 32];
	mac.copy_from_slice(&self.0[..32]);
	mac
	}
	}

	impl AsRef<[u8]> for HmacKeyCredential {
	fn as_ref(&self) -> &[u8] {
	&self.0
	}
	}

	impl Debug for HmacKeyCredential {
	fn fmt(&self, f: &mut Formatter) -> Result<(), Error> {
	write!(
	f,
	"HmacKeyCredential {{ mac: {:?}, nonce: {:?} }}",
	&self.0[..32],
	&self.0[32..]
	)
	}
	}

	impl PartialEq for HmacKeyCredential {
	fn eq(&self, other: &Self) -> bool {
	self.0[..] == other.0[..]
	}
	}

	impl Eq for HmacKeyCredential {}

	const ITERATOR_MAX_LENGTH: usize = 8;

	pub struct HmacCredentialQueue {
	index: usize,
	length: usize,
	list: [Option<(HmacKeyCredential, u32)>; ITERATOR_MAX_LENGTH],
	}

	impl HmacCredentialQueue {
	pub(crate) fn new() -> Self {
	Self {
	index: 0,
	length: 0,
	list: [None; ITERATOR_MAX_LENGTH],
	}
	}

	pub(crate) fn push(&mut self, credential: HmacKeyCredential, counter: u32) -> Result<(), ()> {
	if self.length < ITERATOR_MAX_LENGTH {
	self.list[self.length] = Some((credential, counter));
	self.length += 1;
	Ok(())
	} else {
	Err(())
	}
	}

	pub(crate) fn len(&self) -> usize {
	self.length
	}
	}

	impl Iterator for HmacCredentialQueue {
	type Item = (HmacKeyCredential, u32);

	fn next(&mut self) -> Option<Self::Item> {
	if self.list[self.index].is_some() {
	self.index += 1;
	self.list[self.index - 1]
	} else {
	None
	}
	}
	}

	pub(crate) struct CtapPlatform {
	hmac: HmacDriverFactory,
	}

	impl CtapPlatform {
	fn new(hmac: HmacDriverFactory) -> Self {
	Self { hmac }
	}
	}

	impl fmt::Debug for CtapPlatform {
	fn fmt(&self, _f: &mut fmt::Formatter<'_>) -> fmt::Result {
	Ok(())
	}
	}

	impl CtapPlatform {
	fn generate_key_seed(
	&mut self,
	rp_id: &str,
	nonce: &[u8; 8],
	) -> [u8; libtock::hmac::DEST_BUFFER_SIZE] {
	let hmac_driver;
	match self.hmac.init_driver() {
	Err(_) => {
	panic!("Hmac init error");
	}
	Ok(driver) => {
	hmac_driver = driver;
	}
	}

	let mut key_buffer = HmacKeyBuffer::default();
	for (i, d) in rp_id.as_bytes().iter().enumerate() {
	key_buffer[i] = *d;
	}
	// We need to make sure this isn't dropped straight away
	let key_buffer_ret = hmac_driver.init_key_buffer(&mut key_buffer);
	if key_buffer_ret.is_err() {
	panic!("Hmac key buffer init error");
	}

	let mut data_buffer = HmacDataBuffer::default();
	for (i, d) in nonce.iter().enumerate() {
	data_buffer[i] = *d;
	}
	// We need to make sure this isn't dropped straight away
	let data_buffer_ret = hmac_driver.init_data_buffer(&mut data_buffer);
	if data_buffer_ret.is_err() {
	panic!("Hmac data buffer init error");
	}

	let mut dest_buffer = HmacDestBuffer::default();
	let seed_buffer;
	match hmac_driver.init_dest_buffer(&mut dest_buffer) {
	Err(_) => {
	panic!("Hmac subscribe error");
	}
	Ok(buffer) => {
	seed_buffer = buffer;
	}
	}

	let mut callback = \|_result, _digest\| {};

	// We need to make sure this isn't dropped straight away
	let subscribe = hmac_driver.subscribe(&mut callback);
	if subscribe.is_err() {
	panic!("Hmac subscribe error");
	}

	if hmac_driver.run().is_err() {
	panic!("Hmac run error");
	}

	// Yield waiting for the HMAC callback
	unsafe {
	syscalls::raw::yieldk();
	}

	let mut temp_buffer = [0; libtock::hmac::DEST_BUFFER_SIZE];
	seed_buffer.read_bytes(&mut temp_buffer[..]);
	temp_buffer
	}

	/// Generates a Credential from a CredentialId and checks that the Id is valid
	fn checked_generate_hmac_cred(
	&mut self,
	rp_id: &str,
	credential_id: &[u8],
	) -> Option<HmacKeyCredential> {
	if credential_id.len() != 40 {
	return None;
	}

	let received_mac = &credential_id[..32];

	let seed_buffer = self.generate_key_seed(rp_id, &credential_id[32..40].try_into().unwrap());

	let credential =
	HmacKeyCredential::new(&seed_buffer, credential_id[32..].try_into().unwrap());

	let generated_mac = &credential.0[..32];

	if generated_mac == received_mac {
	Some(credential)
	} else {
	None
	}
	}
	}

	impl AuthenticatorPlatform for CtapPlatform {
	const AAGUID: [u8; 16] = [
	0xf8, 0xa0, 0x11, 0xf3, 0x8c, 0x0a, 0x4d, 0x15, 0x80, 0x06, 0x17, 0x11, 0x1f, 0x9e, 0xdc,
	0x7d,
	];
	const CERTIFICATE: Option<&'static [u8]> = None;
	const MAX_MSG_LENGTH: u16 = 7609;
	const SUPPORTED_OPTIONS: CtapOptions = CtapOptions {
	plat: None,
	rk: Some(true),
	client_pin: None,
	up: Some(true),
	uv: Some(false),
	};
	type CredentialId = HmacKeyCredential;
	type PublicKeyBuffer = [u8; 32];
	type SignatureBuffer = [u8; 32];
	type CredentialIterator = HmacCredentialQueue;

	fn reset(&mut self) -> Result<(), ()> {
	println!("reset");
	unimplemented!()
	}

	fn check_exclude_list(&mut self, _rp_id: &str, _list: CredentialDescriptorList) -> bool {
	println!("check_exclude_list");
	unimplemented!()
	}

	fn locate_credentials(
	&mut self,
	rp_id: &str,
	list: Option<CredentialDescriptorList>,
	) -> (u16, Self::CredentialIterator) {
	match list {
	None => (0, HmacCredentialQueue::new()),
	Some(list) => {
	let mut result = HmacCredentialQueue::new();

	for descriptor in list {
	match self.checked_generate_hmac_cred(rp_id, descriptor.get_id()) {
	None => (),
	Some(credential) => {
	match result.push(credential, 0) {
	Ok(()) => (),
	// NOTE: We just truncate if we don't have enough space to store all
	// fitting credentials
	Err(()) => break,
	}
	}
	}
	}

	(result.len() as u16, result)
	}
	}
	}

	fn create_credential(
	&mut self,
	rp: RpCredential<&[u8], &str>,
	_user: UserCredential<&[u8], &str>,
	) -> (Self::CredentialId, PublicKey<Self::PublicKeyBuffer>, u32) {
	println!("create_credential");
	let rp_id = core::str::from_utf8(rp.rp_id()).unwrap();
	// This nonce is static!!!!
	// This is really bad cryptowise, let's print a warning
	// TODO: Convert this to generate a nonce from Tock's TRNG
	println!("WARNING!!! The nonce is static, this key is insecure");
	println!("WARNING!!! Do not use this anywhere important");
	let nonce = [0; 8];

	let seed_buffer = self.generate_key_seed(rp_id, &nonce);

	let credential = HmacKeyCredential::new(&seed_buffer, nonce.try_into().unwrap());

	let secret_key = SecretKey::from_bytes(&seed_buffer[0..32]).unwrap();

	let pub_key = p256::EncodedPoint::from_secret_key(&secret_key, false);

	let x: [u8; 32] = pub_key.as_bytes()[1..33].try_into().unwrap();
	let y: [u8; 32] = pub_key.as_bytes()[33..].try_into().unwrap();

	let ret_key = PublicKey::nistp256(x, y);

	(credential, ret_key, 0)
	}

	fn attest(
	&mut self,
	id: &Self::CredentialId,
	data: &[u8],
	) -> Option<Signature<Self::SignatureBuffer>> {
	// TODO: Should attest be different then sign?
	let attest = {
	let secret_key = SecretKey::from_bytes(id.get_mac()).unwrap();

	let signer = SigningKey::from(&secret_key);

	let sig = signer.sign(data);

	let mut r: [u8; 32] = [0; 32];
	r.clone_from_slice(&sig.r().as_ref().to_bytes());
	let mut s: [u8; 32] = [0; 32];
	s.clone_from_slice(&sig.s().as_ref().to_bytes());

	Signature::nistp256(r, s)
	};

	Some(attest)
	}

	fn sign(
	&mut self,
	id: &Self::CredentialId,
	data: &[u8],
	) -> Option<Signature<Self::SignatureBuffer>> {
	let attest = {
	let secret_key = SecretKey::from_bytes(id.get_mac()).unwrap();
	let signer = SigningKey::from(&secret_key);
	let sig = signer.sign(data);

	let mut r: [u8; 32] = [0; 32];
	r.clone_from_slice(&sig.r().as_ref().to_bytes());
	let mut s: [u8; 32] = [0; 32];
	s.clone_from_slice(&sig.s().as_ref().to_bytes());

	Signature::nistp256(r, s)
	};

	Some(attest)
	}

	fn start_timeout(&mut self) {
	println!("start_timeout");
	unimplemented!()
	}

	fn has_timed_out(&mut self, _time: Duration) -> bool {
	println!("has_timed_out");
	unimplemented!()
	}
	}

	#[alloc_error_handler]
	unsafe fn alloc_error_handler(_: Layout) -> ! {
	println!("alloc_error_handler called");
	loop {
	syscalls::raw::yieldk();
	}
	}

	#[libtock::main]
	async fn main() -> TockResult<()> {
	let mut tp: Cell<TransactionProcessor<&'static mut [u8], UsbKeyHidPlatform>>;
	let mut temp_buffer = [0; libtock::ctap::RECV_BUFFER_SIZE];
	let mut drivers = libtock::retrieve_drivers()?;
	drivers.console.create_console();

	println!("Starting CTAP feature example");

	let ctap_driver = drivers.ctap.init_driver()?;

	let mut recv_buffer = CtapRecvBuffer::default();
	let recv_buffer = ctap_driver.init_recv_buffer(&mut recv_buffer)?;

	let mut send_buffer = CtapSendBuffer::default();
	let mut send_buffer = ctap_driver.init_send_buffer(&mut send_buffer)?;

	static mut BUFFER: &'static mut [u8] = &mut [0; 2048];
	unsafe {
	tp = Cell::new(TransactionProcessor::new(BUFFER, UsbKeyHidPlatform::new()));
	}

	let mut authenticator = Authenticator::create(CtapPlatform::new(drivers.hmac));

	let mut callback = \|sent, _\| {
	let mut looping = true;
	recv_buffer.read_bytes(&mut temp_buffer[..]);

	let temp_tp = tp.get_mut();
	let mut poll_msg = if sent == 0 { Some(&temp_buffer) } else { None };

	while looping {
	looping = false;
	let (maybe_request, maybe_data) = temp_tp.poll(poll_msg);

	if let Some(request) = maybe_request {
	let response = authenticator.process(request);
	temp_tp.response(response);
	looping = true;
	}

	if let Some(mut data) = maybe_data {
	send_buffer.write_bytes(&mut data[0..]);
	let _ = ctap_driver.send_data();
	}

	poll_msg = None;
	}
	let _ = ctap_driver.allow_receive();
	};

	let _subscription = ctap_driver.subscribe(&mut callback)?;
	ctap_driver.allow_receive()?;

	loop {
	unsafe { syscalls::raw::yieldk() };
	}
	}