tls tidy-up

This commit is contained in:
nworbnhoj 2024-02-29 06:22:38 +10:00
parent 6d24f1af41
commit b217c1546e
3 changed files with 93 additions and 39 deletions

View file

@ -9,6 +9,9 @@ use std::sync::Arc;
use webpki::ring as webpki_algs; use webpki::ring as webpki_algs;
use xous_names::XousNames; use xous_names::XousNames;
/// The entire purpose of the StifledCertificateVerification is to gain access to
/// the certificate-chain-of-trust offered by a host by stifling CertificateError::UnknownIssuer
///
#[derive(Debug)] #[derive(Debug)]
pub struct StifledCertificateVerification { pub struct StifledCertificateVerification {
pub roots: RootCertStore, pub roots: RootCertStore,
@ -16,9 +19,19 @@ pub struct StifledCertificateVerification {
} }
impl StifledCertificateVerification { impl StifledCertificateVerification {
/// rustls includes a sanity check early in the process, to ensure that the RootCertStore
/// contains at least one root certificate before going to the trouble of asking the host
/// to offer its certificate chain of trust. Trouble is, xous/tls wants to probe the host
/// to see what is offered up before deciding if we trust it.
///
/// The somewhat hacky work-around is to add a single bogus TrustAnchor to RootCertStore,
/// and neither the bogus TrustAnchor or the RootCertStore exist beyond the lifetime of
/// this StifledCertificateVerification.
///
pub fn new() -> Self { pub fn new() -> Self {
let mut root_cert_store = rustls::RootCertStore::empty(); let mut root_cert_store = rustls::RootCertStore::empty();
// rustls::ServerCertVerifierBuilder::build() returns a // rustls::ServerCertVerifierBuilder::build() returns a
// `CertVerifierBuilderError` if no trust anchors have been provided. // `CertVerifierBuilderError` if no trust anchors have been provided.
let single_bogus_ta_to_avoid_error_on_empty_roots = TrustAnchor { let single_bogus_ta_to_avoid_error_on_empty_roots = TrustAnchor {
subject: Der::from_slice(b"bogus subject"), subject: Der::from_slice(b"bogus subject"),
@ -59,7 +72,10 @@ impl ServerCertVerifier for StifledCertificateVerification {
CertificateError::UnknownIssuer => Ok(ServerCertVerified::assertion()), CertificateError::UnknownIssuer => Ok(ServerCertVerified::assertion()),
CertificateError::NotValidYet => { CertificateError::NotValidYet => {
modals modals
.show_notification(t!("tls.probe_help_not_valid_yet", locales::LANG), None) .show_notification(
t!("tls.probe_help_not_valid_yet", locales::LANG),
None,
)
.expect("modal failed"); .expect("modal failed");
Err(Error::InvalidCertificate(e)) Err(Error::InvalidCertificate(e))
} }
@ -82,7 +98,7 @@ impl ServerCertVerifier for StifledCertificateVerification {
} }
Err(e) => Err(e), Err(e) => Err(e),
} }
}, }
Err(e) => { Err(e) => {
log::warn!("failed to build WebPkiServerVerifier: {e}"); log::warn!("failed to build WebPkiServerVerifier: {e}");
Err(Error::General("failed to build WebPkiServerVerifier".to_string())) Err(Error::General("failed to build WebPkiServerVerifier".to_string()))
@ -116,6 +132,7 @@ impl ServerCertVerifier for StifledCertificateVerification {
/// Vendor in the sadly private rustls::crypto::ring::SUPPORTED_SIG_ALGS /// Vendor in the sadly private rustls::crypto::ring::SUPPORTED_SIG_ALGS
/// A `WebPkiSupportedAlgorithms` value that reflects webpki's capabilities when /// A `WebPkiSupportedAlgorithms` value that reflects webpki's capabilities when
/// compiled against *ring*. /// compiled against *ring*.
///
static SUPPORTED_SIG_ALGS: WebPkiSupportedAlgorithms = WebPkiSupportedAlgorithms { static SUPPORTED_SIG_ALGS: WebPkiSupportedAlgorithms = WebPkiSupportedAlgorithms {
all: &[ all: &[
webpki_algs::ECDSA_P256_SHA256, webpki_algs::ECDSA_P256_SHA256,

View file

@ -3,11 +3,6 @@ mod danger;
pub mod ota; pub mod ota;
pub mod xtls; pub mod xtls;
use std::convert::{Into, TryFrom, TryInto};
use std::io::{Error, ErrorKind, Read, Write};
use std::net::TcpStream;
use std::sync::Arc;
use locales::t; use locales::t;
use modals::Modals; use modals::Modals;
use ota::OwnedTrustAnchor; use ota::OwnedTrustAnchor;
@ -18,6 +13,10 @@ use rkyv::{
}; };
use rustls::pki_types::{CertificateDer, TrustAnchor}; use rustls::pki_types::{CertificateDer, TrustAnchor};
use rustls::{ClientConfig, ClientConnection, RootCertStore}; use rustls::{ClientConfig, ClientConnection, RootCertStore};
use std::convert::{Into, TryFrom, TryInto};
use std::io::{Error, ErrorKind, Read, Write};
use std::net::TcpStream;
use std::sync::Arc;
use x509_parser::prelude::{parse_x509_certificate, FromDer, X509Certificate}; use x509_parser::prelude::{parse_x509_certificate, FromDer, X509Certificate};
use xous_names::XousNames; use xous_names::XousNames;
@ -43,10 +42,10 @@ impl Tls {
/// # Returns /// # Returns
/// ///
/// a count of trusted certificates /// a count of trusted certificates
///
pub fn trust_modal(&self, certificates: Vec<CertificateDer>) -> usize { pub fn trust_modal(&self, certificates: Vec<CertificateDer>) -> usize {
let xns = XousNames::new().unwrap(); let xns = XousNames::new().unwrap();
let modals = Modals::new(&xns).unwrap(); let modals = Modals::new(&xns).unwrap();
let certificates: Vec<(&[u8], X509Certificate)> = certificates let certificates: Vec<(&[u8], X509Certificate)> = certificates
.iter() .iter()
.map(|cert| X509Certificate::from_der(cert)) .map(|cert| X509Certificate::from_der(cert))
@ -54,7 +53,6 @@ impl Tls {
.map(|result| result.unwrap()) .map(|result| result.unwrap())
.filter(|(_fingerprint, x509)| x509.is_ca()) .filter(|(_fingerprint, x509)| x509.is_ca())
.collect(); .collect();
let chain: Vec<String> = certificates let chain: Vec<String> = certificates
.iter() .iter()
.map(|(fingerprint, x509)| { .map(|(fingerprint, x509)| {
@ -96,6 +94,7 @@ impl Tls {
/// # Returns /// # Returns
/// ///
/// the number of trust-anchors deleted /// the number of trust-anchors deleted
///
pub fn del_all_rota(&self) -> Result<usize, Error> { pub fn del_all_rota(&self) -> Result<usize, Error> {
let count = match self.pddb.list_keys(TLS_TRUSTED_DICT, None) { let count = match self.pddb.list_keys(TLS_TRUSTED_DICT, None) {
Ok(list) => list.len(), Ok(list) => list.len(),
@ -105,10 +104,6 @@ impl Tls {
Ok(_) => { Ok(_) => {
log::info!("Deleted {}\n", TLS_TRUSTED_DICT); log::info!("Deleted {}\n", TLS_TRUSTED_DICT);
self.pddb.sync().or_else(|e| Ok::<(), Error>(log::warn!("{e}"))).ok(); self.pddb.sync().or_else(|e| Ok::<(), Error>(log::warn!("{e}"))).ok();
// match self.pddb.sync() {
// Err(e) => log::warn!("{e}"),
// _ => (),
// }
} }
Err(e) => log::warn!("failed to delete {}: {:?}", TLS_TRUSTED_DICT, e), Err(e) => log::warn!("failed to delete {}: {:?}", TLS_TRUSTED_DICT, e),
} }
@ -120,6 +115,7 @@ impl Tls {
/// # Arguments /// # Arguments
/// ///
/// * `key` - the pddb-key containing the unwanted trust-anchor /// * `key` - the pddb-key containing the unwanted trust-anchor
///
pub fn del_rota(&self, key: &str) -> Result<(), Error> { pub fn del_rota(&self, key: &str) -> Result<(), Error> {
match self.pddb.delete_key(TLS_TRUSTED_DICT, key, None) { match self.pddb.delete_key(TLS_TRUSTED_DICT, key, None) {
Ok(_) => { Ok(_) => {
@ -136,24 +132,29 @@ impl Tls {
/// # Arguments /// # Arguments
/// ///
/// * `ta` - a trusted trust-anchor /// * `ta` - a trusted trust-anchor
///
pub fn save_ta(&self, ta: &OwnedTrustAnchor) -> Result<(), Error> { pub fn save_ta(&self, ta: &OwnedTrustAnchor) -> Result<(), Error> {
match ta.pddb_key() { match ta.pddb_key() {
Ok(key) => { Ok(key) => {
// log::warn!("AAA {:?}", ta); match self.pddb.get(
match self.pddb.get(TLS_TRUSTED_DICT, &key, None, true, true, Some(ota::MAX_OTA_BYTES), None::<fn()>) TLS_TRUSTED_DICT,
{ &key,
None,
true,
true,
Some(ota::MAX_OTA_BYTES),
None::<fn()>,
) {
Ok(mut pddb_key) => { Ok(mut pddb_key) => {
let mut buf = Vec::<u8>::new(); let mut buf = Vec::<u8>::new();
// reserve 2 bytes to hold a u16 (see below) // reserve 2 bytes to hold a u16 (see below)
let reserved = 2; let reserved = 2;
buf.push(0u8); buf.push(0u8);
buf.push(0u8); buf.push(0u8);
// serialize the trust-anchor // serialize the trust-anchor
let mut serializer = WriteSerializer::with_pos(buf, reserved); let mut serializer = WriteSerializer::with_pos(buf, reserved);
let pos = serializer.serialize_value(ta).unwrap(); let pos = serializer.serialize_value(ta).unwrap();
let mut bytes = serializer.into_inner(); let mut bytes = serializer.into_inner();
// copy pop u16 into the first 2 bytes to enable the rkyv archive to be deserialised // copy pop u16 into the first 2 bytes to enable the rkyv archive to be deserialised
let pos: u16 = u16::try_from(pos).expect("data > u16"); let pos: u16 = u16::try_from(pos).expect("data > u16");
let pos_bytes = pos.to_be_bytes(); let pos_bytes = pos.to_be_bytes();
@ -182,6 +183,7 @@ impl Tls {
/// # Arguments /// # Arguments
/// ///
/// * `key` - pddb key holding the trust-anchor /// * `key` - pddb key holding the trust-anchor
///
pub fn get_ota(&self, key: &str) -> Option<OwnedTrustAnchor> { pub fn get_ota(&self, key: &str) -> Option<OwnedTrustAnchor> {
match self.pddb.get(TLS_TRUSTED_DICT, key, None, false, false, None, None::<fn()>) { match self.pddb.get(TLS_TRUSTED_DICT, key, None, false, false, None, None::<fn()>) {
Ok(mut pddb_key) => { Ok(mut pddb_key) => {
@ -211,7 +213,12 @@ impl Tls {
} }
} }
/// Returns a Vec of all trusted trust-anchors /// Returns a Vec of all trusted (saved) OwnedTrustAnchors
///
/// # Returns
///
/// a Vec of OwnedTrustAnchor.
///
pub fn trusted(&self) -> Vec<OwnedTrustAnchor> { pub fn trusted(&self) -> Vec<OwnedTrustAnchor> {
match self.pddb.list_keys(TLS_TRUSTED_DICT, None) { match self.pddb.list_keys(TLS_TRUSTED_DICT, None) {
Ok(list) => list Ok(list) => list
@ -235,6 +242,7 @@ impl Tls {
/// # Returns /// # Returns
/// ///
/// true if the certificate is saved in the TLS_TRUSTED_DICT in the pddb /// true if the certificate is saved in the TLS_TRUSTED_DICT in the pddb
///
pub fn is_trusted_cert(&self, cert: CertificateDer) -> bool { pub fn is_trusted_cert(&self, cert: CertificateDer) -> bool {
match parse_x509_certificate(cert.as_ref()) { match parse_x509_certificate(cert.as_ref()) {
Ok(result) => self.is_trusted_x509(&result.1), Ok(result) => self.is_trusted_x509(&result.1),
@ -255,28 +263,38 @@ impl Tls {
/// ///
/// true if the certificate is saved in the TLS_TRUSTED_DICT in the pddb /// true if the certificate is saved in the TLS_TRUSTED_DICT in the pddb
pub fn is_trusted_x509(&self, x509: &X509Certificate) -> bool { pub fn is_trusted_x509(&self, x509: &X509Certificate) -> bool {
let ta = OwnedTrustAnchor::from(x509); match OwnedTrustAnchor::from_x509(x509) {
match ta.pddb_key() { Ok(ta) => match ta.pddb_key() {
Ok(key) => { Ok(key) => {
match self.pddb.get(TLS_TRUSTED_DICT, &key, None, false, false, None, None::<fn()>) { match self.pddb.get(TLS_TRUSTED_DICT, &key, None, false, false, None, None::<fn()>) {
Ok(_) => { Ok(_) => {
log::info!("trusted: {key}"); log::info!("trusted: {key}");
true true
} }
Err(_) => { Err(_) => {
log::info!("UNtrusted: {key}"); log::info!("UNtrusted: {key}");
false false
}
} }
} }
} Err(e) => {
log::warn!("failed to get pddb_key: {e}");
false
}
},
Err(e) => { Err(e) => {
log::warn!("failed to get pddb_key: {e}"); log::warn!("failed construct OwnedTrustAnchor from x509: {e}");
false false
} }
} }
} }
/// Returns a RootCertStore containing all trusted trust-anchors /// Returns a RootCertStore containing all trusted (saved) TrustAnchors
///
/// # Returns
///
/// a RootCertStore suitable for rustls
///
pub fn root_store(&self) -> RootCertStore { pub fn root_store(&self) -> RootCertStore {
let mut root_store = RootCertStore::empty(); let mut root_store = RootCertStore::empty();
let trusted = match self.pddb.list_keys(TLS_TRUSTED_DICT, None) { let trusted = match self.pddb.list_keys(TLS_TRUSTED_DICT, None) {
@ -295,7 +313,7 @@ impl Tls {
root_store root_store
} }
/// Probes the host and returns the TLS chain of trust /// Probes the host and returns the TLS chain of trust for a host
/// ///
/// Establishes a tls connection to the host, extracts the /// Establishes a tls connection to the host, extracts the
/// certificates offered and immediately closes the connection. /// certificates offered and immediately closes the connection.
@ -369,6 +387,7 @@ impl Tls {
/// # Returns /// # Returns
/// ///
/// the number of trusted Certificates offered by the host /// the number of trusted Certificates offered by the host
///
pub fn inspect(&self, host: &str) -> Result<usize, Error> { pub fn inspect(&self, host: &str) -> Result<usize, Error> {
match self.probe(host) { match self.probe(host) {
Ok(certs) => { Ok(certs) => {
@ -427,6 +446,7 @@ impl Tls {
/// # Returns /// # Returns
/// ///
/// an owned rusttls stream on the tcp-stream provided /// an owned rusttls stream on the tcp-stream provided
///
pub fn stream_owned( pub fn stream_owned(
&self, &self,
host: &str, host: &str,

View file

@ -7,9 +7,12 @@ use std::convert::TryInto;
use std::fmt; use std::fmt;
use std::io::{Error, ErrorKind}; use std::io::{Error, ErrorKind};
use x509_parser::prelude::{FromDer, X509Certificate}; use x509_parser::prelude::{FromDer, X509Certificate};
use x509_parser::x509::X509Name;
pub const MAX_OTA_BYTES: usize = 1028; pub const MAX_OTA_BYTES: usize = 1028;
/// Note that the subject, spki & name_constraints fields are all DER encoded,
/// but WITHOUT the DER header, in keeping with webpki-roots.
#[derive(Archive, Serialize, Deserialize)] #[derive(Archive, Serialize, Deserialize)]
pub struct OwnedTrustAnchor { pub struct OwnedTrustAnchor {
pub subject: Vec<u8>, pub subject: Vec<u8>,
@ -30,6 +33,18 @@ impl OwnedTrustAnchor {
} }
} }
/// Creates a OwnedTrustAnchor from an x509 Certificate
///
/// The Der headers are removed from each of the fields during the conversion.
///
/// # Arguments
///
/// * `x509` - a X509Certificate to create the OwnedTrustAnchor
///
/// # Returns
///
/// An OwnedTrustAnchor based on the supplied X509Certificate
///
pub fn from_x509(x509: &X509Certificate) -> Result<Self, Error> { pub fn from_x509(x509: &X509Certificate) -> Result<Self, Error> {
match ( match (
rm_der_header(x509.subject().as_raw()), rm_der_header(x509.subject().as_raw()),
@ -38,6 +53,7 @@ impl OwnedTrustAnchor {
) { ) {
(Ok(subject), Ok(spki), Ok(name_constraints)) => match name_constraints { (Ok(subject), Ok(spki), Ok(name_constraints)) => match name_constraints {
// Ignore name_constrains for now TODO // Ignore name_constrains for now TODO
// The problem is that it is hard to get access to the raw &[u8] form of name_constraints
Some(_) => Ok(Self::from_subject_spki_name_constraints(subject, spki, None::<&[u8]>)), Some(_) => Ok(Self::from_subject_spki_name_constraints(subject, spki, None::<&[u8]>)),
None => Ok(Self::from_subject_spki_name_constraints(subject, spki, None::<&[u8]>)), None => Ok(Self::from_subject_spki_name_constraints(subject, spki, None::<&[u8]>)),
}, },
@ -63,7 +79,6 @@ impl OwnedTrustAnchor {
Some(begin) => Some(begin), Some(begin) => Some(begin),
None => subject.find("OU="), None => subject.find("OU="),
}; };
let mut pddb_key = match begin { let mut pddb_key = match begin {
Some(mut begin) => { Some(mut begin) => {
begin += 3; begin += 3;
@ -79,11 +94,9 @@ impl OwnedTrustAnchor {
} }
} }
.to_string(); .to_string();
// grab a few arbitrary bytes from spki so pddb_key is deterministic & unique // grab a few arbitrary bytes from spki so pddb_key is deterministic & unique
let k = &self.spki; let k = &self.spki;
pddb_key.push_str(&format!(" {:X}{:X}{:X}{:X}", k[6], k[7], k[8], k[9])); pddb_key.push_str(&format!(" {:X}{:X}{:X}{:X}", k[6], k[7], k[8], k[9]));
// mirror of pddb::KEY_NAME_LEN // mirror of pddb::KEY_NAME_LEN
// u64: vaddr/len/resvd, u32: flags, age = 95 // u64: vaddr/len/resvd, u32: flags, age = 95
// would this be better as a pddb pub? // would this be better as a pddb pub?
@ -100,7 +113,7 @@ impl OwnedTrustAnchor {
// decoded subject // decoded subject
pub fn subject(&self) -> Result<String, Error> { pub fn subject(&self) -> Result<String, Error> {
match add_der_header(Tag::Sequence, &self.subject) { match add_der_header(Tag::Sequence, &self.subject) {
Ok(subject) => match x509_parser::x509::X509Name::from_der(&subject) { Ok(subject) => match X509Name::from_der(&subject) {
Ok((_, decoded)) => Ok(decoded.to_string()), Ok((_, decoded)) => Ok(decoded.to_string()),
Err(e) => { Err(e) => {
log::warn!("failed to decode Subject: {:?}", e); log::warn!("failed to decode Subject: {:?}", e);
@ -113,6 +126,8 @@ impl OwnedTrustAnchor {
} }
} }
} }
}
impl fmt::Debug for OwnedTrustAnchor { impl fmt::Debug for OwnedTrustAnchor {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}\nDer{:?}", self.subject().unwrap_or("Subject error".to_string()), self.spki) write!(f, "{}\nDer{:?}", self.subject().unwrap_or("Subject error".to_string()), self.spki)
@ -142,6 +157,8 @@ impl<'a> Into<TrustAnchor<'a>> for OwnedTrustAnchor {
subject_public_key_info: Der::from(self.spki), subject_public_key_info: Der::from(self.spki),
name_constraints: self.name_constraints.map_or(None, |nc| Some(Der::from(nc))), name_constraints: self.name_constraints.map_or(None, |nc| Some(Der::from(nc))),
} }
}
}
/// Add a DER header to a DER encoded [u8] /// Add a DER header to a DER encoded [u8]
fn add_der_header(tag: Tag, naked: &Vec<u8>) -> Result<Vec<u8>, Error> { fn add_der_header(tag: Tag, naked: &Vec<u8>) -> Result<Vec<u8>, Error> {