feat: snapshot Linux-first RMM MVP and pause handover
Rust development slice / linux (push) Failing after 1m10s
Rust development slice / linux (push) Failing after 1m10s
This commit is contained in:
@@ -0,0 +1,377 @@
|
||||
#![cfg(feature = "postgres-state")]
|
||||
use async_trait::async_trait;
|
||||
use base64::{Engine, engine::general_purpose::URL_SAFE_NO_PAD};
|
||||
use rmm_oidc_auth::{
|
||||
Error, PendingLogin, Result, SecretResolver, StateStore,
|
||||
postgres::{MIGRATION_SQL, PostgresStateStore},
|
||||
};
|
||||
use secrecy::{ExposeSecret, SecretString};
|
||||
use sha2::{Digest, Sha256};
|
||||
use sqlx::{
|
||||
ConnectOptions, Row,
|
||||
postgres::{PgConnectOptions, PgPoolOptions},
|
||||
};
|
||||
use std::{
|
||||
sync::Arc,
|
||||
time::{SystemTime, UNIX_EPOCH},
|
||||
};
|
||||
|
||||
fn must<T, E>(result: std::result::Result<T, E>, message: &str) -> T {
|
||||
result.unwrap_or_else(|_| panic!("{message}"))
|
||||
}
|
||||
fn time() -> u64 {
|
||||
SystemTime::now()
|
||||
.duration_since(UNIX_EPOCH)
|
||||
.unwrap()
|
||||
.as_secs()
|
||||
}
|
||||
fn random() -> String {
|
||||
URL_SAFE_NO_PAD.encode(rand::random::<[u8; 32]>())
|
||||
}
|
||||
fn handle() -> String {
|
||||
URL_SAFE_NO_PAD.encode(Sha256::digest(random().as_bytes()))
|
||||
}
|
||||
fn pending(binding: &str) -> PendingLogin {
|
||||
PendingLogin {
|
||||
binding_hash: binding.into(),
|
||||
nonce: random(),
|
||||
pkce_verifier: random(),
|
||||
expires_at: time() + 300,
|
||||
}
|
||||
}
|
||||
struct Key(SecretString);
|
||||
#[async_trait]
|
||||
impl SecretResolver for Key {
|
||||
async fn resolve(&self, reference: &str) -> Result<SecretString> {
|
||||
if reference != "test-oidc-state-key-v1" && reference != "test-oidc-state-key-v2" {
|
||||
return Err(Error::Secret);
|
||||
}
|
||||
Ok(SecretString::from(self.0.expose_secret().to_owned()))
|
||||
}
|
||||
}
|
||||
|
||||
/// Explicit opt-in; the supplied owner identity must belong to a disposable database.
|
||||
/// The package runner creates a new dedicated container and never uses the server DB.
|
||||
#[tokio::test]
|
||||
#[ignore = "requires isolated PostgreSQL owner test identity; use tests/run_postgres.py"]
|
||||
async fn real_postgres_encrypted_state_nonowner_atomicity_and_limits() {
|
||||
assert_eq!(
|
||||
std::env::var("RMM_OIDC_TEST_ALLOW_OWNER_DDL")
|
||||
.ok()
|
||||
.as_deref(),
|
||||
Some("isolated"),
|
||||
"owner DDL must be explicitly permitted for isolated tests"
|
||||
);
|
||||
let url = must(
|
||||
std::env::var("RMM_OIDC_TEST_DATABASE_URL"),
|
||||
"isolated PostgreSQL URL missing",
|
||||
);
|
||||
let options: PgConnectOptions = must(url.parse(), "invalid isolated PostgreSQL configuration");
|
||||
let options = options.disable_statement_logging();
|
||||
let owner = must(
|
||||
PgPoolOptions::new()
|
||||
.max_connections(2)
|
||||
.connect_with(options.clone())
|
||||
.await,
|
||||
"owner connection failed",
|
||||
);
|
||||
must(
|
||||
sqlx::raw_sql(MIGRATION_SQL).execute(&owner).await,
|
||||
"isolated migration fixture failed",
|
||||
);
|
||||
let role = format!("oidc_auth_test_{:016x}", rand::random::<u64>());
|
||||
let password = format!(
|
||||
"{:032x}{:032x}",
|
||||
rand::random::<u128>(),
|
||||
rand::random::<u128>()
|
||||
);
|
||||
// Both interpolated values are locally generated ASCII hex/identifier characters,
|
||||
// never caller/config input. Runtime adapter queries contain only bind parameters.
|
||||
must(sqlx::raw_sql(&format!(
|
||||
"CREATE ROLE {role} LOGIN PASSWORD '{password}' NOSUPERUSER NOCREATEDB NOCREATEROLE NOINHERIT NOBYPASSRLS; \
|
||||
GRANT USAGE ON SCHEMA rmm_oidc_auth TO {role}; \
|
||||
GRANT SELECT, INSERT, DELETE ON rmm_oidc_auth.login_states TO {role};"
|
||||
)).execute(&owner).await, "isolated nonowner runtime role fixture failed");
|
||||
let runtime = must(
|
||||
PgPoolOptions::new()
|
||||
.max_connections(16)
|
||||
.acquire_timeout(std::time::Duration::from_secs(10))
|
||||
.connect_with(options.username(&role).password(&password))
|
||||
.await,
|
||||
"nonowner runtime connection failed",
|
||||
);
|
||||
let privileges = must(
|
||||
sqlx::query(
|
||||
"SELECT r.rolsuper, r.rolbypassrls, \
|
||||
has_schema_privilege(current_user, 'rmm_oidc_auth', 'CREATE') AS can_create, \
|
||||
c.relowner <> r.oid AS nonowner \
|
||||
FROM pg_roles r CROSS JOIN pg_class c JOIN pg_namespace n ON n.oid=c.relnamespace \
|
||||
WHERE r.rolname=current_user AND n.nspname='rmm_oidc_auth' AND c.relname='login_states'",
|
||||
)
|
||||
.fetch_one(&runtime)
|
||||
.await,
|
||||
"runtime privilege check failed",
|
||||
);
|
||||
assert!(!privileges.get::<bool, _>("rolsuper"));
|
||||
assert!(!privileges.get::<bool, _>("rolbypassrls"));
|
||||
assert!(!privileges.get::<bool, _>("can_create"));
|
||||
assert!(privileges.get::<bool, _>("nonowner"));
|
||||
assert!(
|
||||
sqlx::query("CREATE TABLE rmm_oidc_auth.forbidden_runtime_ddl (id int)")
|
||||
.execute(&runtime)
|
||||
.await
|
||||
.is_err(),
|
||||
"runtime must not create tables"
|
||||
);
|
||||
let resolver = Key(SecretString::from(random()));
|
||||
let store = Arc::new(must(
|
||||
PostgresStateStore::new(
|
||||
runtime.clone(),
|
||||
&resolver,
|
||||
"test-oidc-state-key-v1".into(),
|
||||
100,
|
||||
)
|
||||
.await,
|
||||
"state adapter setup failed",
|
||||
));
|
||||
assert!(store.is_persistent());
|
||||
assert!(matches!(
|
||||
PostgresStateStore::new(
|
||||
runtime.clone(),
|
||||
&Key(SecretString::from("invalid-key")),
|
||||
"test-oidc-state-key-v1".into(),
|
||||
100
|
||||
)
|
||||
.await,
|
||||
Err(Error::Configuration)
|
||||
));
|
||||
assert!(
|
||||
sqlx::query("UPDATE rmm_oidc_auth.login_states SET expires_at=expires_at WHERE false")
|
||||
.execute(&runtime)
|
||||
.await
|
||||
.is_err(),
|
||||
"runtime must not update state"
|
||||
);
|
||||
|
||||
let state = handle();
|
||||
let binding = handle();
|
||||
let login = pending(&binding);
|
||||
let nonce = login.nonce.clone();
|
||||
let verifier = login.pkce_verifier.clone();
|
||||
must(
|
||||
store.insert(state.clone(), login).await,
|
||||
"nonowner insert failed",
|
||||
);
|
||||
let other_version = must(
|
||||
PostgresStateStore::new(
|
||||
runtime.clone(),
|
||||
&resolver,
|
||||
"test-oidc-state-key-v2".into(),
|
||||
100,
|
||||
)
|
||||
.await,
|
||||
"key-version test setup failed",
|
||||
);
|
||||
assert!(
|
||||
matches!(
|
||||
other_version.consume(&state, &binding, time()).await,
|
||||
Err(Error::State)
|
||||
),
|
||||
"a different configured key version must not consume this state"
|
||||
);
|
||||
let saved = must(
|
||||
sqlx::query("SELECT state_hash, binding_hash, ciphertext FROM rmm_oidc_auth.login_states")
|
||||
.fetch_one(&owner)
|
||||
.await,
|
||||
"encrypted fixture inspection failed",
|
||||
);
|
||||
assert_eq!(saved.get::<Vec<u8>, _>("state_hash").len(), 32);
|
||||
assert_eq!(saved.get::<Vec<u8>, _>("binding_hash").len(), 32);
|
||||
let ciphertext: Vec<u8> = saved.get("ciphertext");
|
||||
assert!(
|
||||
!ciphertext
|
||||
.windows(nonce.len())
|
||||
.any(|w| w == nonce.as_bytes())
|
||||
);
|
||||
assert!(
|
||||
!ciphertext
|
||||
.windows(verifier.len())
|
||||
.any(|w| w == verifier.as_bytes())
|
||||
);
|
||||
assert!(
|
||||
matches!(
|
||||
store.consume(&state, &handle(), time()).await,
|
||||
Err(Error::State)
|
||||
),
|
||||
"wrong binding must fail"
|
||||
);
|
||||
assert!(
|
||||
matches!(
|
||||
store.consume(&state, &binding, time() + 600).await,
|
||||
Err(Error::State)
|
||||
),
|
||||
"caller expiry must fail without burning valid state"
|
||||
);
|
||||
assert!(
|
||||
store
|
||||
.insert(state.clone(), pending(&binding))
|
||||
.await
|
||||
.is_err(),
|
||||
"duplicate handle must not overwrite"
|
||||
);
|
||||
let mut tasks = vec![];
|
||||
for _ in 0..16 {
|
||||
let store = store.clone();
|
||||
let state = state.clone();
|
||||
let binding = binding.clone();
|
||||
tasks.push(tokio::spawn(async move {
|
||||
store.consume(&state, &binding, time()).await
|
||||
}));
|
||||
}
|
||||
let mut winners = 0;
|
||||
for task in tasks {
|
||||
match must(task.await, "concurrent callback task failed") {
|
||||
Ok(login) => {
|
||||
winners += 1;
|
||||
assert!(login.nonce == nonce);
|
||||
assert!(login.pkce_verifier == verifier);
|
||||
}
|
||||
Err(error) => assert_eq!(error, Error::State),
|
||||
}
|
||||
}
|
||||
assert_eq!(winners, 1, "exactly one callback may consume state");
|
||||
assert!(
|
||||
matches!(
|
||||
store.consume(&state, &binding, time()).await,
|
||||
Err(Error::State)
|
||||
),
|
||||
"replay must fail"
|
||||
);
|
||||
|
||||
let expired = handle();
|
||||
must(
|
||||
store.insert(expired.clone(), pending(&binding)).await,
|
||||
"expiry fixture insert failed",
|
||||
);
|
||||
must(
|
||||
sqlx::query("UPDATE rmm_oidc_auth.login_states SET created_at=$1, expires_at=$2")
|
||||
.bind(i64::try_from(time() - 600).unwrap())
|
||||
.bind(i64::try_from(time() - 1).unwrap())
|
||||
.execute(&owner)
|
||||
.await,
|
||||
"owner expiry fixture failed",
|
||||
);
|
||||
assert!(
|
||||
matches!(
|
||||
store.consume(&expired, &binding, 0).await,
|
||||
Err(Error::State)
|
||||
),
|
||||
"database clock must prevent revival with an old caller clock"
|
||||
);
|
||||
assert_eq!(
|
||||
must(store.cleanup_expired(1).await, "expiry cleanup failed"),
|
||||
1
|
||||
);
|
||||
assert!(matches!(
|
||||
store.cleanup_expired(1001).await,
|
||||
Err(Error::Configuration)
|
||||
));
|
||||
|
||||
let tampered = handle();
|
||||
must(
|
||||
store.insert(tampered.clone(), pending(&binding)).await,
|
||||
"tamper fixture insert failed",
|
||||
);
|
||||
must(
|
||||
sqlx::query("UPDATE rmm_oidc_auth.login_states SET ciphertext=$1")
|
||||
.bind(vec![0u8; 32])
|
||||
.execute(&owner)
|
||||
.await,
|
||||
"owner tamper fixture failed",
|
||||
);
|
||||
assert!(
|
||||
matches!(
|
||||
store.consume(&tampered, &binding, time()).await,
|
||||
Err(Error::Store)
|
||||
),
|
||||
"tampering must fail authenticated decryption"
|
||||
);
|
||||
assert!(
|
||||
matches!(
|
||||
store.consume(&tampered, &binding, time()).await,
|
||||
Err(Error::State)
|
||||
),
|
||||
"decrypt failure must not restore consumed state"
|
||||
);
|
||||
|
||||
let small = Arc::new(must(
|
||||
PostgresStateStore::new(
|
||||
runtime.clone(),
|
||||
&resolver,
|
||||
"test-oidc-state-key-v1".into(),
|
||||
2,
|
||||
)
|
||||
.await,
|
||||
"capacity adapter setup failed",
|
||||
));
|
||||
let mut tasks = vec![];
|
||||
for _ in 0..8 {
|
||||
let small = small.clone();
|
||||
let binding = binding.clone();
|
||||
tasks.push(tokio::spawn(async move {
|
||||
small.insert(handle(), pending(&binding)).await
|
||||
}));
|
||||
}
|
||||
let mut admitted = 0;
|
||||
for task in tasks {
|
||||
admitted += usize::from(must(task.await, "admission task failed").is_ok());
|
||||
}
|
||||
assert_eq!(
|
||||
admitted, 2,
|
||||
"capacity check must serialize concurrent inserts"
|
||||
);
|
||||
must(
|
||||
sqlx::query("UPDATE rmm_oidc_auth.login_states SET created_at=$1, expires_at=$2")
|
||||
.bind(i64::try_from(time() - 600).unwrap())
|
||||
.bind(i64::try_from(time() - 1).unwrap())
|
||||
.execute(&owner)
|
||||
.await,
|
||||
"cleanup fixtures failed",
|
||||
);
|
||||
assert_eq!(
|
||||
must(store.cleanup_expired(1).await, "bounded cleanup failed"),
|
||||
1
|
||||
);
|
||||
assert_eq!(
|
||||
must(store.cleanup_expired(1).await, "bounded cleanup failed"),
|
||||
1
|
||||
);
|
||||
assert_eq!(
|
||||
must(store.cleanup_expired(1).await, "bounded cleanup failed"),
|
||||
0
|
||||
);
|
||||
assert!(matches!(
|
||||
store
|
||||
.insert("not-a-hashed-state".into(), pending(&binding))
|
||||
.await,
|
||||
Err(Error::State)
|
||||
));
|
||||
let mut too_long = pending(&binding);
|
||||
too_long.expires_at = time() + 3600;
|
||||
assert!(matches!(
|
||||
store.insert(handle(), too_long).await,
|
||||
Err(Error::State)
|
||||
));
|
||||
|
||||
runtime.close().await;
|
||||
must(
|
||||
sqlx::raw_sql(&format!("DROP OWNED BY {role}; DROP ROLE {role};"))
|
||||
.execute(&owner)
|
||||
.await,
|
||||
"isolated role cleanup failed",
|
||||
);
|
||||
owner.close().await;
|
||||
println!(
|
||||
"PostgreSQL: nonowner role verified; concurrent consume winners=1/16; capacity admitted=2/8; encrypted storage, wrong binding, expiry, replay, tampering and bounded cleanup checked"
|
||||
);
|
||||
}
|
||||
Reference in New Issue
Block a user