use super::*;
use std::sync::{
Arc, Mutex,
atomic::{AtomicUsize, Ordering},
mpsc,
};
struct SharedStore {
parent: std::path::PathBuf,
value: Mutex<Option<String>>,
last_login: Mutex<Option<String>>,
attempts: mpsc::Sender<()>,
reads: AtomicUsize,
}
impl Store for SharedStore {
fn lock(&self, origin: &str) -> Result<Box<dyn StoreLock + '_>, GfError> {
self.attempts.send(()).unwrap();
Ok(Box::new(lock_in(&self.parent, origin)?))
}
fn read(&self, key: &str) -> Result<Option<String>, SavedCredentialError> {
if key == LAST_LOGIN_ORIGIN {
return Ok(self.last_login.lock().unwrap().clone());
}
self.reads.fetch_add(1, Ordering::SeqCst);
Ok(self.value.lock().unwrap().clone())
}
fn write(&self, key: &str, value: &str) -> Result<(), GfError> {
if key == LAST_LOGIN_ORIGIN {
*self.last_login.lock().unwrap() = Some(value.into());
return Ok(());
}
*self.value.lock().unwrap() = Some(value.into());
Ok(())
}
fn delete(&self, key: &str) -> Result<(), GfError> {
if key == LAST_LOGIN_ORIGIN {
*self.last_login.lock().unwrap() = None;
return Ok(());
}
*self.value.lock().unwrap() = None;
Ok(())
}
}
struct Provider {
calls: AtomicUsize,
started: mpsc::Sender<()>,
release: Mutex<mpsc::Receiver<()>>,
reply: Mutex<Option<HubResponse>>,
}
impl Transport for Provider {
fn get(
&self,
_: &Url,
_: Option<u64>,
_: Option<&str>,
_: u64,
) -> Result<crate::hub_http::HttpResponse, GfError> {
panic!("unexpected object read")
}
fn exchange(&self, _: &HubRequest, _: usize) -> Result<HubResponse, GfError> {
if self.calls.fetch_add(1, Ordering::SeqCst) == 0 {
self.started.send(()).unwrap();
self.release
.lock()
.unwrap()
.recv_timeout(Duration::from_secs(10))
.unwrap();
return Ok(self.reply.lock().unwrap().take().unwrap());
}
Ok(reply(400, serde_json::json!({"error":"invalid_grant"})))
}
}
fn reply(status: u16, body: serde_json::Value) -> HubResponse {
HubResponse {
status,
headers: Default::default(),
body: serde_json::to_vec(&body).unwrap(),
}
}
fn granted() -> HubResponse {
reply(
200,
serde_json::json!({"access_token":"new-access","refresh_token":"new-refresh","token_type":"Bearer","expires_in":300}),
)
}
struct Harness {
_root: tempfile::TempDir,
store: Arc<SharedStore>,
provider: Arc<Provider>,
attempts: mpsc::Receiver<()>,
started: mpsc::Receiver<()>,
release: mpsc::Sender<()>,
}
impl Harness {
fn new(response: HubResponse, expired: bool) -> Self {
let root = tempfile::tempdir().unwrap();
let (attempts_tx, attempts) = mpsc::channel();
let (started_tx, started) = mpsc::channel();
let (release, release_rx) = mpsc::channel();
let store = Arc::new(SharedStore {
parent: root.path().into(),
value: Mutex::new(Some(
serde_json::to_string(&Session {
access_token: "old-access".into(),
refresh_token: "old-refresh".into(),
expires_at: if expired { 1 } else { 1000 },
})
.unwrap(),
)),
last_login: Mutex::new(None),
attempts: attempts_tx,
reads: AtomicUsize::new(0),
});
let provider = Arc::new(Provider {
calls: AtomicUsize::new(0),
started: started_tx,
release: Mutex::new(release_rx),
reply: Mutex::new(Some(response)),
});
Self {
_root: root,
store,
provider,
attempts,
started,
release,
}
}
fn wait_for_provider(&self) {
self.started.recv_timeout(Duration::from_secs(10)).unwrap();
self.attempts.recv_timeout(Duration::from_secs(10)).unwrap();
self.assert_locked();
}
fn assert_locked(&self) {
let (_directory, file) = lock_file_in(&self.store.parent, DEFAULT_HUB).unwrap();
assert!(
matches!(
fs4::FileExt::try_lock(&file),
Err(fs4::TryLockError::WouldBlock)
),
"the provider call must retain the per-Hub lock"
);
}
fn saved(&self) -> Session {
serde_json::from_str(self.store.value.lock().unwrap().as_ref().unwrap()).unwrap()
}
}
#[test]
fn concurrent_refresh_reads_rotated_pair_instead_of_deleting_it_on_stale_failure() {
let harness = Harness::new(granted(), true);
let store = harness.store.clone();
let provider = harness.provider.clone();
let first = std::thread::spawn(move || {
session(
store.as_ref(),
provider.as_ref(),
&origin(DEFAULT_HUB).unwrap(),
500,
)
.unwrap()
.unwrap()
.access_token
});
harness.wait_for_provider();
let store = harness.store.clone();
let provider = harness.provider.clone();
let second = std::thread::spawn(move || {
session(
store.as_ref(),
provider.as_ref(),
&origin(DEFAULT_HUB).unwrap(),
500,
)
.unwrap()
.unwrap()
.access_token
});
harness
.attempts
.recv_timeout(Duration::from_secs(10))
.unwrap();
assert_eq!(harness.store.reads.load(Ordering::SeqCst), 1);
harness.assert_locked();
harness.release.send(()).unwrap();
assert_eq!(first.join().unwrap(), "new-access");
assert_eq!(second.join().unwrap(), "new-access");
assert_eq!(harness.provider.calls.load(Ordering::SeqCst), 1);
assert_eq!(harness.saved().refresh_token, "new-refresh");
}
#[test]
fn stale_refresh_failure_cannot_delete_a_new_login() {
let harness = Harness::new(
reply(400, serde_json::json!({"error":"invalid_grant"})),
true,
);
let store = harness.store.clone();
let provider = harness.provider.clone();
let refresh = std::thread::spawn(move || {
session(
store.as_ref(),
provider.as_ref(),
&origin(DEFAULT_HUB).unwrap(),
500,
)
.is_err()
});
harness.wait_for_provider();
let store = harness.store.clone();
let login = std::thread::spawn(move || {
save(
store.as_ref(),
&origin(DEFAULT_HUB).unwrap(),
granted(),
500,
)
.unwrap()
.access_token
});
harness
.attempts
.recv_timeout(Duration::from_secs(10))
.unwrap();
harness.assert_locked();
harness.release.send(()).unwrap();
assert!(refresh.join().unwrap());
assert_eq!(login.join().unwrap(), "new-access");
assert_eq!(harness.saved().refresh_token, "new-refresh");
}
#[test]
fn logout_finishes_revocation_and_deletion_before_a_new_login_is_saved() {
let harness = Harness::new(reply(204, serde_json::Value::Null), false);
let store = harness.store.clone();
let provider = harness.provider.clone();
let logout = std::thread::spawn(move || {
super::logout(
store.as_ref(),
provider.as_ref(),
&origin(DEFAULT_HUB).unwrap(),
500,
)
.unwrap()
});
harness.wait_for_provider();
let store = harness.store.clone();
let login = std::thread::spawn(move || {
save(
store.as_ref(),
&origin(DEFAULT_HUB).unwrap(),
granted(),
500,
)
.unwrap()
.access_token
});
harness
.attempts
.recv_timeout(Duration::from_secs(10))
.unwrap();
harness.assert_locked();
harness.release.send(()).unwrap();
logout.join().unwrap();
assert_eq!(login.join().unwrap(), "new-access");
assert_eq!(harness.saved().refresh_token, "new-refresh");
}
#[test]
fn credential_locks_are_private_stable_and_independent_per_origin() {
let root = tempfile::tempdir().unwrap();
let lock = lock_in(root.path(), DEFAULT_HUB).unwrap();
let (_directory, same) = lock_file_in(root.path(), DEFAULT_HUB).unwrap();
assert!(matches!(
fs4::FileExt::try_lock(&same),
Err(fs4::TryLockError::WouldBlock)
));
let (_directory, other) = lock_file_in(root.path(), "https://different.example").unwrap();
fs4::FileExt::try_lock(&other).unwrap();
let identity = graphforge_filesystem::file_identity(&same).unwrap();
assert_eq!(same.metadata().unwrap().len(), 0);
drop(lock);
fs4::FileExt::try_lock(&same).unwrap();
assert_eq!(
graphforge_filesystem::file_identity(&same).unwrap(),
identity
);
}
#[cfg(unix)]
#[test]
fn credential_locks_reject_symlinks_hardlinks_and_insecure_permissions() {
use std::os::unix::fs::{PermissionsExt as _, symlink};
let root = tempfile::tempdir().unwrap();
let other = tempfile::tempdir().unwrap();
let directory = root.path().join(".graphforge-cli-auth-locks");
symlink(other.path(), &directory).unwrap();
assert!(lock_in(root.path(), DEFAULT_HUB).is_err());
std::fs::remove_file(&directory).unwrap();
graphforge_filesystem::create_private_directory(&directory).unwrap();
std::fs::set_permissions(&directory, std::fs::Permissions::from_mode(0o755)).unwrap();
assert!(lock_in(root.path(), DEFAULT_HUB).is_err());
std::fs::set_permissions(&directory, std::fs::Permissions::from_mode(0o700)).unwrap();
let name = lock_name(DEFAULT_HUB);
let path = directory.join(name);
let target = other.path().join("file");
std::fs::write(&target, b"").unwrap();
symlink(&target, &path).unwrap();
assert!(lock_in(root.path(), DEFAULT_HUB).is_err());
std::fs::remove_file(&path).unwrap();
std::fs::hard_link(&target, &path).unwrap();
assert!(lock_in(root.path(), DEFAULT_HUB).is_err());
}