673 lines
25 KiB
Rust
673 lines
25 KiB
Rust
//! Password and TOTP authentication for explicitly provisioned local human users.
|
|
use anyhow::{Result, ensure};
|
|
use axum::http::StatusCode;
|
|
use openssl::{hash::MessageDigest, pkey::PKey, sign::Signer};
|
|
use rmm_domain::jobs::hash;
|
|
use serde::Deserialize;
|
|
use sqlx::PgPool;
|
|
use std::{
|
|
collections::BTreeSet,
|
|
fs::OpenOptions,
|
|
io::Read,
|
|
os::unix::fs::{MetadataExt, OpenOptionsExt, PermissionsExt},
|
|
path::Path,
|
|
sync::{Arc, Mutex},
|
|
time::{Duration, Instant},
|
|
};
|
|
use tokio::sync::Semaphore;
|
|
use uuid::Uuid;
|
|
|
|
const SCRYPT_N: u64 = 1 << 17;
|
|
const SCRYPT_MAX_MEMORY: u64 = 256 * 1024 * 1024;
|
|
|
|
#[derive(Deserialize)]
|
|
#[serde(deny_unknown_fields)]
|
|
struct FileConfig {
|
|
schema_version: u32,
|
|
users: Vec<FileUser>,
|
|
}
|
|
#[derive(Deserialize)]
|
|
#[serde(deny_unknown_fields)]
|
|
struct FileUser {
|
|
username: String,
|
|
principal: String,
|
|
tenant_id: Uuid,
|
|
disabled: bool,
|
|
password_scrypt: PasswordHash,
|
|
totp_secret_base32: String,
|
|
}
|
|
#[derive(Deserialize)]
|
|
#[serde(deny_unknown_fields)]
|
|
struct PasswordHash {
|
|
salt_hex: String,
|
|
hash_hex: String,
|
|
}
|
|
#[derive(Clone)]
|
|
struct Account {
|
|
username: String,
|
|
principal: String,
|
|
tenant: Uuid,
|
|
disabled: bool,
|
|
salt: Vec<u8>,
|
|
password_hash: Vec<u8>,
|
|
secret: Vec<u8>,
|
|
}
|
|
pub struct LocalAuth {
|
|
users: Vec<Account>,
|
|
attempts: Mutex<Vec<Vec<Instant>>>,
|
|
workers: Arc<Semaphore>,
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
#[serde(deny_unknown_fields)]
|
|
pub struct Login {
|
|
username: String,
|
|
password: String,
|
|
totp_code: String,
|
|
}
|
|
|
|
fn username_valid(value: &str) -> bool {
|
|
!value.is_empty()
|
|
&& value.len() <= 64
|
|
&& value
|
|
.bytes()
|
|
.all(|b| b.is_ascii_alphanumeric() || b"_.@-".contains(&b))
|
|
}
|
|
fn decode_secret(value: &str) -> Result<Vec<u8>> {
|
|
ensure!(
|
|
value.len() == 32,
|
|
"TOTP requires exactly 160 bits in unpadded uppercase base32"
|
|
);
|
|
let mut bytes = Vec::with_capacity(20);
|
|
let mut buffer = 0u16;
|
|
let mut bits = 0;
|
|
for b in value.bytes() {
|
|
let digit = match b {
|
|
b'A'..=b'Z' => b - b'A',
|
|
b'2'..=b'7' => b - b'2' + 26,
|
|
_ => anyhow::bail!("Invalid TOTP base32"),
|
|
};
|
|
buffer = (buffer << 5) | u16::from(digit);
|
|
bits += 5;
|
|
if bits >= 8 {
|
|
bits -= 8;
|
|
bytes.push((buffer >> bits) as u8);
|
|
buffer &= (1 << bits) - 1;
|
|
}
|
|
}
|
|
ensure!(bytes.len() == 20 && bits == 0, "Invalid TOTP secret length");
|
|
Ok(bytes)
|
|
}
|
|
fn derive_password(password: &[u8], salt: &[u8]) -> Result<[u8; 64]> {
|
|
let mut derived = [0; 64];
|
|
openssl::pkcs5::scrypt(
|
|
password,
|
|
salt,
|
|
SCRYPT_N,
|
|
8,
|
|
1,
|
|
SCRYPT_MAX_MEMORY,
|
|
&mut derived,
|
|
)?;
|
|
Ok(derived)
|
|
}
|
|
fn code(secret: &[u8], step: u64) -> Result<u32> {
|
|
let key = PKey::hmac(secret)?;
|
|
let mut signer = Signer::new(MessageDigest::sha1(), &key)?;
|
|
signer.update(&step.to_be_bytes())?;
|
|
let mac = signer.sign_to_vec()?;
|
|
let offset = usize::from(mac[19] & 15);
|
|
let value = u32::from_be_bytes(mac[offset..offset + 4].try_into()?) & 0x7fff_ffff;
|
|
Ok(value % 1_000_000)
|
|
}
|
|
fn matching_step(secret: &[u8], supplied: &str, now: i64) -> Result<Option<i64>> {
|
|
if supplied.len() != 6 || !supplied.bytes().all(|b| b.is_ascii_digit()) || now < 30 {
|
|
return Ok(None);
|
|
}
|
|
let current = now / 30;
|
|
let mut matched = None;
|
|
for step in current - 1..=current + 1 {
|
|
let expected = format!("{:06}", code(secret, step as u64)?);
|
|
if openssl::memcmp::eq(expected.as_bytes(), supplied.as_bytes()) {
|
|
// If adjacent timesteps happen to collide, consume the highest one.
|
|
matched = Some(step);
|
|
}
|
|
}
|
|
Ok(matched)
|
|
}
|
|
impl LocalAuth {
|
|
pub fn configured() -> Result<Option<Self>> {
|
|
let Some(path) = std::env::var_os("RMM_LOCAL_AUTH_FILE") else {
|
|
return Ok(None);
|
|
};
|
|
let path = Path::new(&path);
|
|
ensure!(path.is_absolute(), "Local auth path must be absolute");
|
|
let mut file = OpenOptions::new()
|
|
.read(true)
|
|
.custom_flags(libc::O_NOFOLLOW)
|
|
.open(path)
|
|
.map_err(|_| anyhow::anyhow!("Local authentication file unavailable"))?;
|
|
let metadata = file.metadata()?;
|
|
ensure!(
|
|
metadata.is_file()
|
|
&& metadata.uid() == 10001
|
|
&& metadata.permissions().mode() & 0o777 == 0o600
|
|
&& metadata.nlink() == 1
|
|
&& metadata.len() <= 65536,
|
|
"Unsafe local authentication file"
|
|
);
|
|
let mut content = Vec::new();
|
|
file.by_ref().take(65537).read_to_end(&mut content)?;
|
|
ensure!(
|
|
content.len() <= 65536,
|
|
"Oversized local authentication file"
|
|
);
|
|
Self::parse(&content).map(Some)
|
|
}
|
|
fn parse(content: &[u8]) -> Result<Self> {
|
|
let config: FileConfig = serde_json::from_slice(content)
|
|
.map_err(|_| anyhow::anyhow!("Invalid local authentication configuration"))?;
|
|
ensure!(
|
|
config.schema_version == 1 && !config.users.is_empty() && config.users.len() <= 100,
|
|
"Invalid local authentication schema or user limit"
|
|
);
|
|
let mut usernames = BTreeSet::new();
|
|
let mut principals = BTreeSet::new();
|
|
let mut users = Vec::new();
|
|
for user in config.users {
|
|
let id = user
|
|
.principal
|
|
.strip_prefix("local:")
|
|
.and_then(|s| Uuid::parse_str(s).ok())
|
|
.filter(|id| !id.is_nil() && user.principal == format!("local:{id}"));
|
|
ensure!(
|
|
id.is_some()
|
|
&& !user.tenant_id.is_nil()
|
|
&& username_valid(&user.username)
|
|
&& usernames.insert(user.username.clone())
|
|
&& principals.insert(user.principal.clone()),
|
|
"Invalid or duplicate local identity"
|
|
);
|
|
let salt = hex::decode(&user.password_scrypt.salt_hex)?;
|
|
let password_hash = hex::decode(&user.password_scrypt.hash_hex)?;
|
|
ensure!(
|
|
salt.len() == 32 && password_hash.len() == 64,
|
|
"Invalid scrypt credential"
|
|
);
|
|
users.push(Account {
|
|
username: user.username,
|
|
principal: user.principal,
|
|
tenant: user.tenant_id,
|
|
disabled: user.disabled,
|
|
salt,
|
|
password_hash,
|
|
secret: decode_secret(&user.totp_secret_base32)?,
|
|
});
|
|
}
|
|
Ok(Self {
|
|
attempts: Mutex::new(vec![vec![]; users.len() + 1]),
|
|
users,
|
|
workers: Arc::new(Semaphore::new(1)),
|
|
})
|
|
}
|
|
pub fn home(&self, principal: &str) -> Option<Uuid> {
|
|
self.users
|
|
.iter()
|
|
.find(|user| !user.disabled && user.principal == principal)
|
|
.map(|user| user.tenant)
|
|
}
|
|
pub fn enabled(&self, principal: &str, tenant: Uuid) -> bool {
|
|
self.users
|
|
.iter()
|
|
.any(|u| !u.disabled && u.principal == principal && u.tenant == tenant)
|
|
}
|
|
fn limit(&self, index: usize) -> Result<(), StatusCode> {
|
|
let mut buckets = self
|
|
.attempts
|
|
.lock()
|
|
.map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?;
|
|
let attempts = &mut buckets[index];
|
|
attempts.retain(|t| t.elapsed() < Duration::from_secs(60));
|
|
if attempts.len() >= 6 {
|
|
return Err(StatusCode::TOO_MANY_REQUESTS);
|
|
}
|
|
attempts.push(Instant::now());
|
|
Ok(())
|
|
}
|
|
pub async fn authenticate(
|
|
&self,
|
|
pool: &PgPool,
|
|
input: Login,
|
|
) -> Result<crate::auth::Principal, StatusCode> {
|
|
if !username_valid(&input.username)
|
|
|| input.password.is_empty()
|
|
|| input.password.len() > 1024
|
|
|| input.totp_code.len() != 6
|
|
|| !input.totp_code.bytes().all(|b| b.is_ascii_digit())
|
|
{
|
|
return Err(StatusCode::UNAUTHORIZED);
|
|
}
|
|
let index = self.users.iter().position(|u| u.username == input.username);
|
|
self.limit(index.unwrap_or(self.users.len()))?;
|
|
let permit = self
|
|
.workers
|
|
.clone()
|
|
.try_acquire_owned()
|
|
.map_err(|_| StatusCode::TOO_MANY_REQUESTS)?;
|
|
// Unknown usernames perform the same expensive derivation against a fixed dummy record.
|
|
let account = index.map(|i| self.users[i].clone());
|
|
let checking = account.clone().unwrap_or(Account {
|
|
username: String::new(),
|
|
principal: String::new(),
|
|
tenant: Uuid::nil(),
|
|
disabled: true,
|
|
salt: vec![0; 32],
|
|
password_hash: vec![0; 64],
|
|
secret: vec![0; 20],
|
|
});
|
|
let matched = tokio::task::spawn_blocking(move || -> Result<Option<i64>> {
|
|
let _permit = permit; // Held until computation ends, including a disconnected HTTP caller.
|
|
let password = derive_password(input.password.as_bytes(), &checking.salt)?;
|
|
let matches = openssl::memcmp::eq(&password, &checking.password_hash);
|
|
let step = matching_step(
|
|
&checking.secret,
|
|
&input.totp_code,
|
|
chrono::Utc::now().timestamp(),
|
|
)?;
|
|
Ok(step.filter(|_| matches && !checking.disabled))
|
|
})
|
|
.await
|
|
.map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?
|
|
.map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?;
|
|
let account = account.ok_or(StatusCode::UNAUTHORIZED)?;
|
|
let step = matched.ok_or(StatusCode::UNAUTHORIZED)?;
|
|
consume(pool, &account, step).await?;
|
|
Ok(crate::auth::Principal {
|
|
tenant: account.tenant,
|
|
name: account.principal,
|
|
operator: true,
|
|
session_hash: None,
|
|
csrf: None,
|
|
scopes: None,
|
|
testsimulation: false,
|
|
identity: None,
|
|
tenants: vec![account.tenant],
|
|
})
|
|
}
|
|
}
|
|
async fn consume(pool: &PgPool, account: &Account, step: i64) -> Result<(), StatusCode> {
|
|
let mut tx = rmm_persistence::tenant_tx(pool, account.tenant)
|
|
.await
|
|
.map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?;
|
|
let consumed: bool = sqlx::query_scalar("SELECT local_totp_consume($1,$2,$3)")
|
|
.bind(&account.principal)
|
|
.bind(hash(&account.secret))
|
|
.bind(step)
|
|
.fetch_one(&mut *tx)
|
|
.await
|
|
.map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?;
|
|
if !consumed {
|
|
return Err(StatusCode::UNAUTHORIZED);
|
|
}
|
|
tx.commit()
|
|
.await
|
|
.map_err(|_| StatusCode::SERVICE_UNAVAILABLE)
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use chrono::Utc;
|
|
use serde_json::json;
|
|
|
|
fn sample(principal: &str, tenant: Uuid, password_hash: &str) -> serde_json::Value {
|
|
json!({"schema_version":1,"users":[{
|
|
"username":"kevin","principal":principal,"tenant_id":tenant,"disabled":false,
|
|
"password_scrypt":{"salt_hex":hex::encode([7;32]),"hash_hex":password_hash},
|
|
"totp_secret_base32":"GEZDGNBVGY3TQOJQGEZDGNBVGY3TQOJQ"
|
|
}]})
|
|
}
|
|
fn configured(data: &serde_json::Value) -> LocalAuth {
|
|
LocalAuth::parse(&serde_json::to_vec(data).unwrap()).unwrap()
|
|
}
|
|
fn input(password: &str, secret: &[u8]) -> Login {
|
|
Login {
|
|
username: "kevin".into(),
|
|
password: password.into(),
|
|
totp_code: format!(
|
|
"{:06}",
|
|
code(secret, (Utc::now().timestamp() / 30) as u64).unwrap()
|
|
),
|
|
}
|
|
}
|
|
#[test]
|
|
fn rfc6238_and_strict_adjacent_steps() {
|
|
let secret = decode_secret("GEZDGNBVGY3TQOJQGEZDGNBVGY3TQOJQ").unwrap();
|
|
assert_eq!(secret, b"12345678901234567890");
|
|
for (now, expected) in [
|
|
(59, 287082),
|
|
(1111111109, 81804),
|
|
(1111111111, 50471),
|
|
(1234567890, 5924),
|
|
(2000000000, 279037),
|
|
(20000000000, 353130),
|
|
] {
|
|
let text = format!("{expected:06}");
|
|
assert_eq!(code(&secret, (now / 30) as u64).unwrap(), expected);
|
|
assert_eq!(matching_step(&secret, &text, now).unwrap(), Some(now / 30));
|
|
}
|
|
let now = 1_234_567_890;
|
|
for offset in [-1, 0, 1] {
|
|
let text = format!("{:06}", code(&secret, (now / 30 + offset) as u64).unwrap());
|
|
assert_eq!(
|
|
matching_step(&secret, &text, now).unwrap(),
|
|
Some(now / 30 + offset)
|
|
);
|
|
}
|
|
let old = format!("{:06}", code(&secret, (now / 30 - 2) as u64).unwrap());
|
|
assert_eq!(matching_step(&secret, &old, now).unwrap(), None);
|
|
for text in ["", "12345", "1234567", "12 456", "123456"] {
|
|
assert_eq!(matching_step(&secret, text, now).unwrap(), None);
|
|
}
|
|
}
|
|
#[test]
|
|
fn rejects_ambiguous_configuration_and_bounds_rate_limit() {
|
|
let p = format!("local:{}", Uuid::new_v4());
|
|
let tenant = Uuid::new_v4();
|
|
let good = sample(&p, tenant, &hex::encode([1; 64]));
|
|
let local = configured(&good);
|
|
assert!(local.enabled(&p, tenant));
|
|
assert!(!local.enabled(&p, Uuid::new_v4()));
|
|
for _ in 0..6 {
|
|
assert!(local.limit(0).is_ok());
|
|
}
|
|
assert_eq!(local.limit(0), Err(StatusCode::TOO_MANY_REQUESTS));
|
|
let mut disabled = good.clone();
|
|
disabled["users"][0]["disabled"] = json!(true);
|
|
assert!(!configured(&disabled).enabled(&p, tenant));
|
|
for (key, value) in [
|
|
("principal", json!("simulated-testprincipal-a")),
|
|
("tenant_id", json!(Uuid::nil())),
|
|
("totp_secret_base32", json!("short")),
|
|
("username", json!("../kevin")),
|
|
] {
|
|
let mut bad = good.clone();
|
|
bad["users"][0][key] = value;
|
|
assert!(LocalAuth::parse(&serde_json::to_vec(&bad).unwrap()).is_err());
|
|
}
|
|
let mut duplicate = good.clone();
|
|
duplicate["users"]
|
|
.as_array_mut()
|
|
.unwrap()
|
|
.push(good["users"][0].clone());
|
|
assert!(LocalAuth::parse(&serde_json::to_vec(&duplicate).unwrap()).is_err());
|
|
}
|
|
|
|
#[tokio::test]
|
|
#[ignore = "requires isolated PostgreSQL with current migrations"]
|
|
async fn restricted_token_rejects_foreign_detail_and_plan_routes() {
|
|
use axum::{Router, middleware, routing::get};
|
|
use serde_json::Value;
|
|
|
|
let admin = PgPool::connect(&std::env::var("RMM_TEST_REPAIR_ADMIN_URL").unwrap())
|
|
.await
|
|
.unwrap();
|
|
let pool = sqlx::postgres::PgPoolOptions::new()
|
|
.max_connections(1)
|
|
.acquire_timeout(std::time::Duration::from_secs(3))
|
|
.connect(&std::env::var("RMM_TEST_REPAIR_APP_URL").unwrap())
|
|
.await
|
|
.unwrap();
|
|
let a = Uuid::parse_str(rmm_domain::TENANT_A).unwrap();
|
|
let b = Uuid::parse_str(rmm_domain::TENANT_B).unwrap();
|
|
let issuer = format!("local:{}", Uuid::new_v4());
|
|
let id = Uuid::new_v4();
|
|
let asset = Uuid::new_v4();
|
|
let token = format!("rmm_mcp_{}", "A".repeat(43));
|
|
let scopes = vec!["inventory:read", "operations:plan", "operations:read"];
|
|
sqlx::query("INSERT INTO memberships(tenant_id,principal,kind,permissions) VALUES($1,$2,'human',$3)")
|
|
.bind(a).bind(&issuer).bind([scopes.as_slice(), &["tokens:manage"]].concat())
|
|
.execute(&admin).await.unwrap();
|
|
let mut tx = rmm_persistence::tenant_tx(&pool, a).await.unwrap();
|
|
sqlx::query("SELECT issue_customer_token($1,$2,'Restricted HTTP fixture',$3,$4,now()+interval '1 hour',false,$5)")
|
|
.bind(&issuer).bind(id).bind(hash(token.as_bytes())).bind(&scopes).bind(vec![a]).execute(&mut *tx).await.unwrap();
|
|
tx.commit().await.unwrap();
|
|
sqlx::query("INSERT INTO assets(tenant_id,asset_id) VALUES($1,$2)")
|
|
.bind(b)
|
|
.bind(asset)
|
|
.execute(&admin)
|
|
.await
|
|
.unwrap();
|
|
let fingerprint = hash(asset.as_bytes());
|
|
sqlx::query("INSERT INTO agent_installations(tenant_id,agent_id,asset_id,certificate_sha256,last_contact_at,last_authenticated_certificate_sha256,last_authenticated_at) VALUES($1,$2,$3,$4,now(),$4,now())")
|
|
.bind(b).bind(Uuid::new_v4()).bind(asset).bind(fingerprint).execute(&admin).await.unwrap();
|
|
let mut config = sample(&issuer, a, &hex::encode([1; 64]));
|
|
let mut auth = crate::auth::Auth::from_env("development").await.unwrap();
|
|
auth.local = Some(configured(&config));
|
|
let key_dir = std::env::temp_dir().join(id.to_string());
|
|
let state = crate::State {
|
|
pool: pool.clone(),
|
|
signer: None,
|
|
viewer_a: [0; 32],
|
|
viewer_b: [1; 32],
|
|
auth: Arc::new(auth),
|
|
job_signer: Arc::new(
|
|
crate::job_signer::JobSigner::load_or_create(&key_dir.join("http-test.key"))
|
|
.unwrap(),
|
|
),
|
|
};
|
|
let router = crate::jobs::routes(
|
|
Router::new()
|
|
.route("/api/v1/tenants", get(crate::api::tenants))
|
|
.route(
|
|
"/api/v1/tenants/{tenant}/devices/{asset}",
|
|
get(crate::devices::detail),
|
|
),
|
|
)
|
|
.layer(middleware::from_fn(crate::auth::context))
|
|
.with_state(state.clone());
|
|
let listener = tokio::net::TcpListener::bind(("127.0.0.1", 0))
|
|
.await
|
|
.unwrap();
|
|
let base = format!("http://{}/api/v1/tenants", listener.local_addr().unwrap());
|
|
let server = tokio::spawn(async move { axum::serve(listener, router).await.unwrap() });
|
|
let client = reqwest::Client::builder()
|
|
.timeout(std::time::Duration::from_secs(5))
|
|
.build()
|
|
.unwrap();
|
|
let response = client.get(&base).bearer_auth(&token).send().await.unwrap();
|
|
assert_eq!(response.status(), StatusCode::OK);
|
|
let directory = response.json::<Value>().await.unwrap();
|
|
assert_eq!(directory["items"].as_array().unwrap().len(), 1);
|
|
assert_eq!(directory["items"][0]["tenant_id"], a.to_string());
|
|
let now = Utc::now();
|
|
let forbidden_plan = json!({"tenant_id":b,"action":"refresh_inventory","targets":{"asset_ids":[asset]},
|
|
"parameters":{"execution_identity":"agent_service","timeout_seconds":60,"max_output_bytes":4096,"scope":"base"},
|
|
"schedule":{"not_before":now,"start_before":now+chrono::Duration::minutes(5),"offline_policy":"wait_until_deadline"},
|
|
"rollout":{"max_parallel":1,"halt_after_failures":1},"reason":"test customer authorization"});
|
|
for request in [
|
|
client.get(format!("{base}/{b}/devices/{asset}")),
|
|
client
|
|
.post(format!("{base}/{b}/operation-plans"))
|
|
.json(&forbidden_plan),
|
|
] {
|
|
let denied = request
|
|
.bearer_auth(&token)
|
|
.header("x-rmm-tenant", a.to_string())
|
|
.send()
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(denied.status(), StatusCode::NOT_FOUND);
|
|
}
|
|
let member = format!("mcp:{id}");
|
|
let created: i64 = sqlx::query_scalar(
|
|
"SELECT count(*) FROM operation_plans WHERE tenant_id=$1 AND principal=$2",
|
|
)
|
|
.bind(b)
|
|
.bind(&member)
|
|
.fetch_one(&admin)
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(created, 0);
|
|
server.abort();
|
|
config["users"][0]["disabled"] = json!(true);
|
|
let mut disabled = crate::auth::Auth::from_env("development").await.unwrap();
|
|
disabled.local = Some(configured(&config));
|
|
let suspended = crate::State {
|
|
auth: Arc::new(disabled),
|
|
..state
|
|
};
|
|
assert!(matches!(
|
|
crate::mcp_tokens::authenticate(&suspended, &token, None).await,
|
|
Err(StatusCode::UNAUTHORIZED)
|
|
));
|
|
let mut tx = rmm_persistence::tenant_tx(&pool, a).await.unwrap();
|
|
assert!(
|
|
!crate::jobs::requester_enabled(&suspended, &mut tx, &member, a)
|
|
.await
|
|
.unwrap()
|
|
);
|
|
tx.commit().await.unwrap();
|
|
std::fs::remove_dir_all(key_dir).unwrap();
|
|
}
|
|
|
|
#[tokio::test]
|
|
#[ignore = "requires isolated PostgreSQL with current migrations"]
|
|
async fn local_password_totp_database() {
|
|
let admin = PgPool::connect(&std::env::var("RMM_TEST_REPAIR_ADMIN_URL").unwrap())
|
|
.await
|
|
.unwrap();
|
|
let pool = PgPool::connect(&std::env::var("RMM_TEST_REPAIR_APP_URL").unwrap())
|
|
.await
|
|
.unwrap();
|
|
rmm_persistence::verify_application_role(&pool)
|
|
.await
|
|
.unwrap();
|
|
let tenant = Uuid::new_v4();
|
|
let p = format!("local:{}", Uuid::new_v4());
|
|
sqlx::query("INSERT INTO tenants(tenant_id,name) VALUES($1,'local auth test')")
|
|
.bind(tenant)
|
|
.execute(&admin)
|
|
.await
|
|
.unwrap();
|
|
sqlx::query("INSERT INTO memberships(tenant_id,principal,kind,permissions) VALUES($1,$2,'human',ARRAY['inventory:read'])")
|
|
.bind(tenant).bind(&p).execute(&admin).await.unwrap();
|
|
let password = "isolated unit test password";
|
|
let derived = derive_password(password.as_bytes(), &[7; 32]).unwrap();
|
|
let data = sample(&p, tenant, &hex::encode(derived));
|
|
let local = configured(&data);
|
|
let secret = &local.users[0].secret;
|
|
let held = local.workers.clone().acquire_owned().await.unwrap();
|
|
assert_eq!(
|
|
local
|
|
.authenticate(&pool, input(password, secret))
|
|
.await
|
|
.err(),
|
|
Some(StatusCode::TOO_MANY_REQUESTS)
|
|
);
|
|
drop(held);
|
|
assert_eq!(
|
|
local
|
|
.authenticate(&pool, input("wrong password", secret))
|
|
.await
|
|
.err(),
|
|
Some(StatusCode::UNAUTHORIZED)
|
|
);
|
|
let mut incorrect = input(password, secret);
|
|
incorrect.totp_code = "x".repeat(6);
|
|
assert_eq!(
|
|
local.authenticate(&pool, incorrect).await.err(),
|
|
Some(StatusCode::UNAUTHORIZED)
|
|
);
|
|
let mut wrong_code = input(password, secret);
|
|
let current = Utc::now().timestamp();
|
|
wrong_code.totp_code = (0..1_000_000)
|
|
.map(|n| format!("{n:06}"))
|
|
.find(|v| matching_step(secret, v, current).unwrap().is_none())
|
|
.unwrap();
|
|
assert_eq!(
|
|
local.authenticate(&pool, wrong_code).await.err(),
|
|
Some(StatusCode::UNAUTHORIZED)
|
|
);
|
|
let valid_input = input(password, secret);
|
|
let consumed_code = valid_input.totp_code.clone();
|
|
let valid = local.authenticate(&pool, valid_input).await.unwrap();
|
|
assert_eq!(valid.name, p);
|
|
assert_eq!(valid.tenant, tenant);
|
|
assert!(!valid.testsimulation);
|
|
assert!(valid.session_hash.is_none());
|
|
assert_eq!(
|
|
local
|
|
.authenticate(
|
|
&pool,
|
|
Login {
|
|
username: "kevin".into(),
|
|
password: password.into(),
|
|
totp_code: consumed_code.clone()
|
|
}
|
|
)
|
|
.await
|
|
.err(),
|
|
Some(StatusCode::UNAUTHORIZED)
|
|
);
|
|
// Replay remains rejected by the database after constructing a fresh auth provider.
|
|
let restarted = configured(&data);
|
|
assert_eq!(
|
|
restarted
|
|
.authenticate(
|
|
&pool,
|
|
Login {
|
|
username: "kevin".into(),
|
|
password: password.into(),
|
|
totp_code: consumed_code
|
|
}
|
|
)
|
|
.await
|
|
.err(),
|
|
Some(StatusCode::UNAUTHORIZED)
|
|
);
|
|
let mut disabled = data.clone();
|
|
disabled["users"][0]["disabled"] = json!(true);
|
|
assert_eq!(
|
|
configured(&disabled)
|
|
.authenticate(&pool, input(password, secret))
|
|
.await
|
|
.err(),
|
|
Some(StatusCode::UNAUTHORIZED)
|
|
);
|
|
|
|
let step = Utc::now().timestamp() / 30 + 1;
|
|
let a = consume(&pool, &local.users[0], step);
|
|
let b = consume(&pool, &local.users[0], step);
|
|
let (one, two) = tokio::join!(a, b);
|
|
assert_eq!(usize::from(one.is_ok()) + usize::from(two.is_ok()), 1);
|
|
assert_eq!(one.err().or(two.err()), Some(StatusCode::UNAUTHORIZED));
|
|
let foreign = Account {
|
|
tenant: Uuid::new_v4(),
|
|
..local.users[0].clone()
|
|
};
|
|
assert_eq!(
|
|
consume(&pool, &foreign, step + 1).await,
|
|
Err(StatusCode::UNAUTHORIZED)
|
|
);
|
|
sqlx::query("UPDATE memberships SET revoked_at=now() WHERE tenant_id=$1 AND principal=$2")
|
|
.bind(tenant)
|
|
.bind(&p)
|
|
.execute(&admin)
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(
|
|
consume(&pool, &local.users[0], step + 1).await,
|
|
Err(StatusCode::UNAUTHORIZED)
|
|
);
|
|
sqlx::query("UPDATE memberships SET revoked_at=NULL,kind='automation' WHERE tenant_id=$1 AND principal=$2")
|
|
.bind(tenant).bind(&p).execute(&admin).await.unwrap();
|
|
assert_eq!(
|
|
consume(&pool, &local.users[0], step + 1).await,
|
|
Err(StatusCode::UNAUTHORIZED)
|
|
);
|
|
pool.close().await;
|
|
admin.close().await;
|
|
}
|
|
}
|