[Fix] User deletion & migration

iota-util/src/tu.rs

@@ -0,0 +1,95 @@
+//! Strict parsing and storage-independent handling of user credentials.
+//!
+//! A `.tu` file is deliberately identified by the account id embedded in its
+//! contents.  Its filename is presentation data owned by the CLI, never an
+//! account authority.
+
+use crate::crypto_helper::{keyring_from_base64, keyring_to_base64};
+use mtp::crypto::{Keyring, PublicKeyBundle};
+use std::fmt;
+
+pub const MAX_PROTOCOL_ID: i64 = (1_i64 << 48) - 1;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum TuError {
+    InvalidFormat,
+    InvalidUserId,
+    InvalidKeyring,
+}
+
+impl fmt::Display for TuError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(match self {
+            Self::InvalidFormat => "invalid .tu credential format",
+            Self::InvalidUserId => "invalid .tu user id",
+            Self::InvalidKeyring => "invalid .tu keyring",
+        })
+    }
+}
+
+impl std::error::Error for TuError {}
+
+pub struct TuCredential {
+    pub user_id: i64,
+    pub omega_host: String,
+    pub keyring: Keyring,
+}
+
+impl fmt::Debug for TuCredential {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("TuCredential")
+            .field("user_id", &self.user_id)
+            .field("omega_host", &self.omega_host)
+            .field("keyring", &"<redacted>")
+            .finish()
+    }
+}
+
+impl TuCredential {
+    pub fn parse(input: &str) -> Result<Self, TuError> {
+        let (identity, encoded_keyring) = input.trim().split_once("::").ok_or(TuError::InvalidFormat)?;
+        if encoded_keyring.is_empty() || encoded_keyring.contains("::") {
+            return Err(TuError::InvalidFormat);
+        }
+        let (user_id, omega_host) = identity.split_once('@').ok_or(TuError::InvalidFormat)?;
+        if omega_host.trim().is_empty() || omega_host.contains('@') {
+            return Err(TuError::InvalidFormat);
+        }
+        let user_id = user_id.parse::<i64>().map_err(|_| TuError::InvalidUserId)?;
+        if !(1..=MAX_PROTOCOL_ID).contains(&user_id) {
+            return Err(TuError::InvalidUserId);
+        }
+        let keyring = keyring_from_base64(encoded_keyring).ok_or(TuError::InvalidKeyring)?;
+        Ok(Self { user_id, omega_host: omega_host.trim().to_owned(), keyring })
+    }
+
+    pub fn public_key_bundle(&self) -> PublicKeyBundle {
+        self.keyring.public_key_bundle()
+    }
+
+    pub fn to_canonical_string(&self) -> String {
+        format!("{}@{}::{}", self.user_id, self.omega_host, keyring_to_base64(&self.keyring))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::crypto_helper::generate_keyring;
+
+    #[test]
+    fn round_trip_is_canonical() {
+        let credential = TuCredential { user_id: 42, omega_host: "omega.example:443".into(), keyring: generate_keyring() };
+        let parsed = TuCredential::parse(&credential.to_canonical_string()).unwrap();
+        assert_eq!(parsed.user_id, 42);
+        assert_eq!(parsed.omega_host, "omega.example:443");
+        assert_eq!(parsed.to_canonical_string(), credential.to_canonical_string());
+    }
+
+    #[test]
+    fn rejects_malformed_credentials() {
+        for value in ["", "1@omega", "@omega::abc", "0@omega::abc", "281474976710656@omega::abc", "1@::abc", "1@omega::abc::def"] {
+            assert!(TuCredential::parse(value).is_err(), "{value}");
+        }
+    }
+}