diff --git a/libs/tls/README.md b/libs/tls/README.md deleted file mode 100644 index a0dda3812..000000000 --- a/libs/tls/README.md +++ /dev/null @@ -1,41 +0,0 @@ -== TLS == - -A tls library focused on explicitly trusting Certificate Authority Certificates (requires `--feature tls`). - -Typically, operating systems and browsers embed a list of implicitly trusted Root CA certificates. - -The tls handshake involves the host offering the client a Certificate signed for authenticity by a CA, with a chain of signatures back to a Root CA. If the client trusts at least one Certificate in this chain of trust, then the handshake may progress to an encrypted connection. - -It does not seem in keeping with the Precursor/Xous idea to ask users to trust any such list of Root CA Certificates. - -This tls library enables the user to obtain and save trusted CA certificates to the PDDB as a personalised set of trusted Root CA certificates on which to establish a tls connection. This can be as simple for the user as responding to a modal, when making a first connection to an as yet un-trusted host. Just a couple of clicks. The developer need only call `Tls::check_trust()`. - -Note that hosts with self-signed Certificates may be probed and trusted (e.g. [chat.signal.org](https://chat.signal.org)) - -A small set of shellchat commands are included to enact the base functionality: - -- `net tls probe ` will initiate a modified tls handshake with ``, obtain the certificate chain offered by ``, and immediately terminate the connection. A call to Tls::check_trust() will present the CA certificate chain in a modal to be individually selected and saved to PDDB if trusted. -- `net tls test ` will attempt a normal tls handshake with `` based on the trusted Root CA certificates in the PDDB. If the connection is successful, then a simple `get` is emitted, the response accepted, and the connection closed. -- `net tls mozilla` trusts and saves all Root CA's in the [webpki-roots crate](https://crates.io/crates/webpki-roots) - which contains Mozilla's root certificates. (requires `--feature rootCA`) -- `net list` lists all trusted certificates in the PDDB -- `net deleteall` deletes all trusted certificates in the PDDB - -These functions are gated by 2 feature flags: -- `tls` includes [der](https://crates.io/crates/der), [ring](https://crates.io/crates/ring) (local patch), [rustls](https://crates.io/crates/rustls), [webpki](https://crates.io/crates/webpki) & [x509-parser](https://crates.io/crates/x509-parser) -- `rootCA` includes the [webpki-roots crate](https://crates.io/crates/webpki-roots) - -In keeping with `rustls` & `webpki`, only the critical components of each x509-Certificate are stored in the PDDB under the `tls.trusted` dictionary - as a `rkyv` archive of a `tls::RustTlsOwnedTrustAuthority` object. - -The rustls [dangerous_configuration](https://github.com/betrusted-io/xous-core/pull/394/commits/4ea0c8457de8f855723af76546b6ecb7e54661f7) feature is required to modify the tls handshake during a `net tls probe `. This is because, by default, `rustls` drops the connection (and certificate chain) if there is no match to a trusted Root CA Certificate in the `RootStore`. During a `probe` we need to briefly trust all CA certificates in order to get hold of the CA certificate chain, and inspect it. - -The shellchat `net tls` commands are are called from `services/shellchat/src/cmds/net_cmd.rs`, but located in `libs/tls/src/cmd.rs` in order to contain the size of `services/shellchat/src/cmds/net_cmd.rs` and to keep the tls cmds close to the implementation. - -Native `pddb` calls are used throuought (`std::fs` free) - -Considerations: - -- there is an outstanding **issue** where the `checkbox` modal does not display options with multiple lines correctly. This impacts the display of fingerprints for some certificates with longer subjects. -- It may be worth considering rendering public `pddb::KEY_NAME_LEN` to allow developer to avoid sending overly long key's which will be rejected by the pddb. -- probably need a shellchat `net tls delete ` -- some broken code is included for a future fix if required [RustlsOwnedTrustAnchor::publik_key()](https://github.com/betrusted-io/xous-core/pull/394/commits/4e0298c17ad2c51aa220a88dc69bf2f56e51076f) -- some hosts (eg bunnyfoo.com) emit an `unexpected eof` error during tls handshake 🤷 diff --git a/libs/tls/src/cmd.rs b/libs/tls/src/cmd.rs index ebc533cbe..da877270f 100644 --- a/libs/tls/src/cmd.rs +++ b/libs/tls/src/cmd.rs @@ -1,4 +1,4 @@ -use crate::Tls; +use crate::{danger, Tls}; use locales::t; #[cfg(feature = "rootCA")] use modals::Modals; @@ -53,7 +53,7 @@ pub fn shellchat<'a>( ) }) .collect(); - let mut count: u32 = rotas.len().try_into().unwrap(); + let mut count:u32 = rotas.len().try_into().unwrap(); let xns = XousNames::new().unwrap(); let modals = Modals::new(&xns).unwrap(); modals @@ -75,20 +75,60 @@ pub fn shellchat<'a>( // pddb if trusted. Some("probe") => { log::set_max_level(log::LevelFilter::Info); + log::info!("starting TLS probe"); + // Attempt to open the tls connection with an empty root_store + let root_store = rustls::RootCertStore::empty(); + // Stifle the default rustls certificate verification's complaint about an + // unknown/untrusted CA root certificate so that we get to see the certificate chain + let stifled_verifier = + Arc::new(danger::StifledCertificateVerification { roots: root_store }); + let config = rustls::ClientConfig::builder() + .with_safe_defaults() + .with_custom_certificate_verifier(stifled_verifier) + .with_no_client_auth(); let target = match tokens.next() { Some(target) => target, - None => "betrusted.io", + None => "bunnyfoo.com", }; - let tls = Tls::new(); - match tls.probe(target) { - Ok(count) => write!(ret, "{} {}", count, t!("tls.probe_done", locales::LANG)).ok(), - Err(_) => write!( + let server_name = target.try_into().unwrap_or_else(|e| { + log::warn!("failed to create sever_name from {target}: {e}"); + write!( ret, "{} {target}", t!("tls.probe_fail_servername", locales::LANG) ) - .ok(), + .ok(); + "bunnyfoo.com".try_into().unwrap() + }); + let mut conn = rustls::ClientConnection::new(Arc::new(config), server_name).unwrap(); + log::info!("connect TCPstream to {}", target); + let url = format!("{}:443", target); + match TcpStream::connect(url) { + Ok(mut sock) => { + match conn.complete_io(&mut sock) { + Ok(_) => log::info!("handshake complete"), + Err(e) => { + write!(ret, "{e}").ok(); + log::warn!("{e}"); + } + } + conn.send_close_notify(); + + match conn.peer_certificates() { + Some(certificates) => { + let tls = Tls::new(); + let count = tls.check_trust(certificates); + write!(ret, "{} {}", count, t!("tls.probe_done", locales::LANG)).ok(); + } + None => (), + }; + } + Err(e) => { + write!(ret, "{e}").ok(); + log::warn!("{e}") + } }; + log::set_max_level(log::LevelFilter::Info); } @@ -159,12 +199,7 @@ pub fn shellchat<'a>( } None | _ => { write!(ret, "{}\n", t!("tls.cmd", locales::LANG)).ok(); - write!( - ret, - "\tdeleteall\t{}\n", - t!("tls.deleteall_cmd", locales::LANG) - ) - .ok(); + write!(ret, "\tdeleteall\t{}\n", t!("tls.deleteall_cmd", locales::LANG)).ok(); write!(ret, "\thelp\n").ok(); write!(ret, "\tlist\t{}\n", t!("tls.list_cmd", locales::LANG)).ok(); #[cfg(feature = "rootCA")] diff --git a/libs/tls/src/lib.rs b/libs/tls/src/lib.rs index aa703f633..fdf7451ce 100644 --- a/libs/tls/src/lib.rs +++ b/libs/tls/src/lib.rs @@ -1,5 +1,5 @@ pub mod cmd; -mod danger; +pub mod danger; pub mod rota; use crate::rota::RustlsOwnedTrustAnchor; @@ -31,17 +31,9 @@ impl Tls { } } - /// Presents a modal to the user to select trusted tls certificates - /// and saves the selected certificates to the pddb - /// - /// # Arguments - /// - /// * `certificates` - the certificates to be presented - /// - /// # Returns - /// - /// a count of trusted certificates - /// + // presents a modal to the user to select trusted tls certificates + // and saves the selected certificates to the pddb + // returns a count of trusted certificates pub fn check_trust(&self, certificates: &[Certificate]) -> usize { let xns = XousNames::new().unwrap(); let modals = Modals::new(&xns).unwrap(); @@ -100,12 +92,8 @@ impl Tls { } } - /// Deletes ALL tls trust-anchors from the pddb - /// - /// # Returns - /// - /// the number of trust-anchors deleted - /// + // deletes ALL tls trust-anchors from the pddb + // returns the number of certs deleted pub fn del_all_cert(&self) -> Result { let count = match self.pddb.list_keys(TLS_TRUSTED_DICT, None) { Ok(list) => list.len(), @@ -128,12 +116,7 @@ impl Tls { Ok(count) } - /// Deletes a tls trust-anchor from the pddb - /// - /// # Arguments - /// - /// * `key` - the pddb-key containing the unwanted trust-anchor - /// + // deletes a tls trust-anchor from the pddb pub fn del_cert(&self, key: &str) -> Result<(), Error> { match self.pddb.delete_key(TLS_TRUSTED_DICT, key, None) { Ok(_) => { @@ -148,12 +131,7 @@ impl Tls { return Ok(()); } - /// Saves a tls trust-anchor to the pddb - /// - /// # Arguments - /// - /// * `ta` - a trusted trust-anchor - /// + // saves a tls trust-anchor to the pddb pub fn save_cert(&self, ta: &RustlsOwnedTrustAnchor) -> Result<(), Error> { let key = ta.pddb_key(); match self.pddb.get( @@ -197,12 +175,8 @@ impl Tls { Ok(()) } - /// Returns a tls trust-anchor from the pddb - /// - /// # Arguments - /// - /// * `key` - pddb key holding the trust-anchor - /// + + // retrieves a tls trust-anchor from the pddb pub fn get_cert(&self, key: &str) -> Option { match self.pddb.get( TLS_TRUSTED_DICT, @@ -221,8 +195,9 @@ impl Tls { let pos: u16 = u16::from_be_bytes([bytes[0], bytes[1]]); let pos: usize = pos.into(); // deserialize the trust-anchor - let archive = - unsafe { rkyv::archived_value::(&bytes, pos) }; + let archive = unsafe { + rkyv::archived_value::(&bytes, pos) + }; let ta = archive.deserialize(&mut AllocDeserializer {}).ok(); log::info!("get '{}' = '{:?}'", key, &ta); ta @@ -240,8 +215,6 @@ impl Tls { } } - /// Returns a Vec of all trusted trust-anchors - /// pub fn trusted(&self) -> Vec { match self.pddb.list_keys(TLS_TRUSTED_DICT, None) { Ok(list) => list @@ -256,8 +229,6 @@ impl Tls { } } - /// Returns a RootCertStore containing all trusted trust-anchors - /// pub fn root_store(&self) -> RootCertStore { let mut root_store = RootCertStore::empty(); match self.pddb.list_keys(TLS_TRUSTED_DICT, None) { @@ -273,65 +244,6 @@ impl Tls { } root_store } - - /// Probes the target and returns true is at least 1 certificate is trusted - /// - /// Establishes a tls connection to the target host, extracts the - /// certificates offered and immediately closes the connection. - /// The certificates are presented by modal to the user, and saved to the - /// pddb if trusted. - /// - /// By default, rustls only provides access to a trusted certificate chain. - /// Probe briefly stifles the certificate validation (ie trusts everything) - /// in order to grab the untrusted cetificate chain and present it to the - /// user for examination. - /// - /// # Arguments - /// - /// * `target` - the target tls site (i.e. betrusted.io) - /// - pub fn probe(&self, target: &str) -> Result { - log::info!("starting TLS probe"); - // Attempt to open the tls connection with an empty root_store - let root_store = rustls::RootCertStore::empty(); - // Stifle the default rustls certificate verification's complaint about an - // unknown/untrusted CA root certificate so that we get to see the certificate chain - let stifled_verifier = - Arc::new(danger::StifledCertificateVerification { roots: root_store }); - let config = rustls::ClientConfig::builder() - .with_safe_defaults() - .with_custom_certificate_verifier(stifled_verifier) - .with_no_client_auth(); - match target.try_into() { - Ok(server_name) => { - let mut conn = - rustls::ClientConnection::new(Arc::new(config), server_name).unwrap(); - log::info!("connect TCPstream to {}", target); - let url = format!("{}:443", target); - match TcpStream::connect(url) { - Ok(mut sock) => { - match conn.complete_io(&mut sock) { - Ok(_) => log::info!("handshake complete"), - Err(e) => log::warn!("{e}"), - } - conn.send_close_notify(); - match conn.peer_certificates() { - Some(certificates) => Ok(self.check_trust(certificates)), - None => Ok(0), - } - } - Err(e) => { - log::warn!("{e}"); - Err(e) - } - } - } - Err(e) => { - log::warn!("failed to create sever_name from {target}: {e}"); - Err(Error::from(ErrorKind::InvalidInput)) - } - } - } } // https://stackoverflow.com/questions/57029974/how-to-split-string-into-chunks-in-rust-to-insert-spaces