fix #14740: fixed backend url per build, key bound to its server

- the backend URL is no longer a setting: one constant per build
  (release/dev) in src-tauri/src/backend.rs; Settings shows the server
  read-only; an old backend_url in settings.json is ignored
- the stored key records the backend it was created for; a key of
  another backend is discarded before any use and never stored
- a refused key is discarded only if it still is the stored one
- the keyring is never called while the settings are locked
- one upload per call at a time, also visible after a view switch
- opener plugin without its link-click script (it also ran in the
  remote login page); a login error says to reload the login page

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
This commit is contained in:
hauke
2026-11-06 15:18:05 +01:00
co-authored by Claude Opus 5.5
parent f045424e97
commit 3358de7888
10 changed files with 399 additions and 217 deletions
+31 -59
View File
@@ -16,33 +16,12 @@ use serde_json::{json, Value};
use crate::http::{HttpBody, HttpRequest, HttpResponse, HttpTransport, Method};
/// The backend the app talks to unless the user sets another one.
pub const DEFAULT_URL: &str = "https://test.euvinopro.eu";
/// The admin login page, relative to the backend URL.
const LOGIN_PATH: &str = "/euvadm";
const KEY_HEADER: &str = "X-Admin-Api-Key";
/// Longest key label the backend accepts, in characters.
const MAX_LABEL_CHARS: usize = 100;
/// Checks a backend URL the user typed: `https` with a host, no user name,
/// query or fragment. Returns it without trailing slashes.
pub fn normalize_url(url: &str) -> Result<String, String> {
let invalid = || {
"Backend-URL: bitte eine https-Adresse wie https://test.euvinopro.eu angeben".to_string()
};
let parsed = Url::parse(url.trim()).map_err(|_| invalid())?;
let usable = parsed.scheme() == "https"
&& parsed.host_str().is_some_and(|host| !host.is_empty())
&& parsed.username().is_empty()
&& parsed.password().is_none()
&& parsed.query().is_none()
&& parsed.fragment().is_none();
if !usable {
return Err(invalid());
}
Ok(parsed.as_str().trim_end_matches('/').to_string())
}
/// The label of a key this app creates: "Gesprächsrekorder (<hostname>)",
/// at most 100 characters.
pub fn key_label(hostname: Option<&str>) -> String {
@@ -137,8 +116,8 @@ pub struct BackendClient {
}
impl BackendClient {
/// `base_url` as checked by [`normalize_url`]; a trailing slash is
/// ignored.
/// `base_url` is the backend's https origin (plus path prefix, if
/// any); a trailing slash is ignored.
pub fn new(transport: Arc<dyn HttpTransport>, base_url: &str) -> Self {
Self {
transport,
@@ -146,6 +125,12 @@ impl BackendClient {
}
}
/// The backend this client talks to, without trailing slash. A key it
/// creates belongs to this backend only.
pub fn base_url(&self) -> &str {
&self.base_url
}
/// The admin login page the login window opens.
pub fn login_url(&self) -> String {
format!("{}{LOGIN_PATH}", self.base_url)
@@ -351,8 +336,9 @@ pub trait Login: Send + Sync {
/// Runs the login flow; returns the new (already stored) key, or the
/// message why there is none.
async fn login(&self) -> Result<String, String>;
/// Forgets the stored key the backend refused.
async fn discard_key(&self);
/// Forgets the stored key if it still is `refused`, the key the backend
/// just refused (a login meanwhile may have stored a new one).
async fn discard_key(&self, refused: &str);
}
/// Uploads `text` with the stored key, logging in first when there is no
@@ -372,11 +358,11 @@ pub async fn upload_with_login(
};
match client.upload_transcript(&key, text).await {
Err(BackendError::InvalidKey) => {
login.discard_key().await;
login.discard_key(&key).await;
let key = login.login().await?;
let result = client.upload_transcript(&key, text).await;
if result == Err(BackendError::InvalidKey) {
login.discard_key().await;
login.discard_key(&key).await;
}
result.map_err(|e| e.user_message())
}
@@ -467,31 +453,6 @@ mod tests {
}
}
#[test]
fn urls_must_be_https_with_a_host() {
assert_eq!(
normalize_url(" https://test.euvinopro.eu/ "),
Ok("https://test.euvinopro.eu".to_string())
);
assert_eq!(
normalize_url("https://backend.example:8443/sub/"),
Ok("https://backend.example:8443/sub".to_string())
);
let invalid = "Backend-URL: bitte eine https-Adresse wie https://test.euvinopro.eu angeben";
for url in [
"",
"test.euvinopro.eu",
"http://test.euvinopro.eu",
"https://",
"https://user:pw@test.euvinopro.eu",
"https://test.euvinopro.eu/?a=1",
"https://test.euvinopro.eu/#x",
"ftp://test.euvinopro.eu",
] {
assert_eq!(normalize_url(url), Err(invalid.to_string()), "{url:?}");
}
}
#[test]
fn the_key_label_names_the_computer_within_100_chars() {
assert_eq!(
@@ -510,8 +471,10 @@ mod tests {
let (_, client) = client();
assert_eq!(client.login_url(), "https://backend.example/euvadm");
assert_eq!(client.keys_page_url(), KEYS);
assert_eq!(client.base_url(), BASE);
let slash = BackendClient::new(Arc::new(FakeTransport::new()), "https://backend.example/");
assert_eq!(slash.login_url(), "https://backend.example/euvadm");
assert_eq!(slash.base_url(), BASE);
}
#[test]
@@ -831,12 +794,12 @@ mod tests {
assert!(!format!("{:?}", stored("euv_secret", None)).contains("euv_secret"));
}
/// Scripted [`Login`]: hands out the given results in order and counts
/// discards.
/// Scripted [`Login`]: hands out the given results in order and
/// records the discarded keys.
struct FakeLogin {
results: Mutex<Vec<Result<String, String>>>,
logins: Mutex<usize>,
discards: Mutex<usize>,
discarded: Mutex<Vec<String>>,
}
impl FakeLogin {
@@ -844,12 +807,19 @@ mod tests {
Self {
results: Mutex::new(results),
logins: Mutex::new(0),
discards: Mutex::new(0),
discarded: Mutex::new(Vec::new()),
}
}
fn counts(&self) -> (usize, usize) {
(*self.logins.lock().unwrap(), *self.discards.lock().unwrap())
(
*self.logins.lock().unwrap(),
self.discarded.lock().unwrap().len(),
)
}
fn discarded(&self) -> Vec<String> {
self.discarded.lock().unwrap().clone()
}
}
@@ -860,8 +830,8 @@ mod tests {
self.results.lock().unwrap().remove(0)
}
async fn discard_key(&self) {
*self.discards.lock().unwrap() += 1;
async fn discard_key(&self, refused: &str) {
self.discarded.lock().unwrap().push(refused.to_string());
}
}
@@ -923,6 +893,7 @@ mod tests {
assert_eq!(id, Ok("crm-9".into()));
assert_eq!(login.counts(), (1, 1));
assert_eq!(login.discarded(), ["euv_old"]);
let keys: Vec<_> = transport
.requests()
.iter()
@@ -943,6 +914,7 @@ mod tests {
assert_eq!(result, Err(BackendError::InvalidKey.user_message()));
assert_eq!(login.counts(), (1, 2));
assert_eq!(login.discarded(), ["euv_old", "euv_new"]);
transport.assert_done();
}