General Upgrade, NEW: WebServers, Better Docs

example/server/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "server"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2024"
 
 [[bin]]
@@ -8,10 +8,8 @@ name = "server"
 path = "src/main.rs"
 
 [dependencies]
-mtp = { version = "0.1.0", path = "../../", features = ["crypto", "host", "files", "pipes"] }
-rcgen = "0.14"
+mtp = { version = "0.2.0", path = "../../", features = ["crypto", "tls", "host", "files", "pipes"] }
 tokio = { version = "1", features = ["full"] }
 serde_json = { version = "1" }
 hex = "0.4"
 base64 = "0.22"
-time = "0.3"

example/server/src/keys.rs

@@ -1,7 +1,7 @@
 use std::fs;
 
 use mtp::crypto::Keyring;
-use mtp::files::{load_keyring, save_keyring, save_public_key_bundle};
+use mtp::files::{load_keyring_raw, save_keyring_raw, save_public_key_bundle};
 
 /* Host id is fixed for the example; only the keyring itself is persisted. */
 const HOST_ID: u64 = 1;
@@ -9,13 +9,13 @@ const HOST_ID: u64 = 1;
 pub fn load_or_generate_host_keys(
     keyring_path: &str,
 ) -> Result<(u64, Keyring), Box<dyn std::error::Error>> {
-    if let Ok(keyring) = load_keyring(keyring_path) {
+    if let Ok(keyring) = load_keyring_raw(keyring_path) {
         println!("Loaded host keyring from {keyring_path}");
         return Ok((HOST_ID, keyring));
     }
 
     let keyring = Keyring::generate();
-    save_keyring(&keyring, keyring_path)?;
+    save_keyring_raw(&keyring, keyring_path)?;
     println!("Generated host keyring -> {keyring_path}");
     Ok((HOST_ID, keyring))
 }

example/server/src/main.rs

@@ -86,13 +86,14 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let (_host_id, host_keyring) = keys::load_or_generate_host_keys("host.mk")?;
     keys::export_host_public_keys(&host_keyring)?;
 
-    let decrypt_keyring = Arc::new(match mtp::crypto::Keyring::from_bytes(&host_keyring.to_bytes())
-    {
-        Ok(keyring) => keyring,
-        Err(e) => {
-            return Err(format!("failed to re-load host keyring for decryption: {e}").into());
-        }
-    });
+    let decrypt_keyring = Arc::new(
+        match mtp::crypto::Keyring::from_bytes(&host_keyring.to_bytes()) {
+            Ok(keyring) => keyring,
+            Err(e) => {
+                return Err(format!("failed to re-load host keyring for decryption: {e}").into());
+            }
+        },
+    );
 
     let (clients, next_id) = clients::load_client_db("clients.json")?;
 
@@ -100,7 +101,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let get_existing_user = move |id: u64, _description: Option<String>| {
         let clients = clients_for_get.clone();
         Box::pin(async move {
-            let result = clients.lock()?.get(&id).cloned();
+            let result = clients.lock().unwrap().get(&id).cloned();
             if result.is_some() {
                 println!("Auth lookup: client ID {id} found");
             } else {
@@ -119,8 +120,8 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         let nid_arc = next_id_for_register.clone();
         let path = clients_path.clone();
         Box::pin(async move {
-            let mut db = db_arc.lock()?;
-            let mut nid = nid_arc.lock()?;
+            let mut db = db_arc.lock().unwrap();
+            let mut nid = nid_arc.lock().unwrap();
             let id = *nid;
             *nid += 1;
             db.insert(id, bundle);
@@ -166,7 +167,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
             );
             println!("Client ID: {}", conn.client_id);
 
-            let tm: &TypeMap = conn.codec.registry().get(&conn.version)?;
+            let tm: &TypeMap = conn.codec.registry().get(&conn.version).unwrap();
 
             println!("Waiting for messages / pipe requests ...");
             loop {

example/server/src/tls.rs

@@ -1,9 +1,6 @@
 use base64::Engine;
-use rcgen::{CertificateParams, ExtendedKeyUsagePurpose, IsCa, KeyPair, KeyUsagePurpose, SanType};
 use std::fs;
-use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
 use std::path::Path;
-use time::{Duration, OffsetDateTime};
 
 pub fn load_or_generate_tls(
     cert_path: &str,
@@ -22,35 +19,13 @@ pub fn load_or_generate_tls(
         fs::create_dir_all(parent)?;
     }
 
-    let key_pair = KeyPair::generate_for(&rcgen::PKCS_ECDSA_P256_SHA256)?;
+    let (cert_pem, key_pem) = mtp::crypto::tls::generate_self_signed_cert("localhost")?;
 
-    let mut params = CertificateParams::new(vec!["localhost".into()])?;
-    params.not_before = OffsetDateTime::now_utc() - Duration::minutes(5);
-    params.not_after = OffsetDateTime::now_utc() + Duration::days(13);
-
-    params
-        .subject_alt_names
-        .push(SanType::IpAddress(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1))));
-    params
-        .subject_alt_names
-        .push(SanType::IpAddress(IpAddr::V6(Ipv6Addr::new(
-            0, 0, 0, 0, 0, 0, 0, 1,
-        ))));
-
-    params.key_usages = vec![KeyUsagePurpose::DigitalSignature];
-    params.extended_key_usages = vec![ExtendedKeyUsagePurpose::ServerAuth];
-    params.is_ca = IsCa::NoCa;
-
-    let cert = params.self_signed(&key_pair)?;
-
-    let cert_str = cert.pem();
-    let key_str = key_pair.serialize_pem();
-
-    fs::write(cert_path, cert_str.as_bytes())?;
-    fs::write(key_path, key_str.as_bytes())?;
+    fs::write(cert_path, &cert_pem)?;
+    fs::write(key_path, &key_pem)?;
     println!("Wrote {cert_path} and {key_path}");
 
-    Ok((cert_str.into_bytes(), key_str.into_bytes()))
+    Ok((cert_pem, key_pem))
 }
 
 pub fn certificate_sha256_hex(cert: &[u8]) -> Result<String, Box<dyn std::error::Error>> {