122 lines
3.6 KiB
Rust
122 lines
3.6 KiB
Rust
//! 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}");
|
|
}
|
|
}
|
|
}
|