1use kanidm_client::{ClientError, KanidmClient};
19use kanidm_proto::internal::OperationError;
20use kanidm_proto::v1::Entry;
21use kaniop_k8s_util::types::normalize_spn;
22use kaniop_operator::metrics::{
23 ControllerMetrics, KANIDM_OP_ADD_MEMBERS, KANIDM_OP_CREATE, KANIDM_OP_DELETE, KANIDM_OP_GET,
24 KANIDM_OP_REMOVE_MEMBERS, KANIDM_OUTCOME_CHANGED, KANIDM_OUTCOME_UNCHANGED,
25};
26use kube::ResourceExt;
27use thiserror::Error;
28use uuid::Uuid;
29
30use crate::crd::KanidmRadiusServer;
31use crate::reconcile::error::{ExecError, ExecResult, kanidm_error};
32use crate::reconcile::sdk;
33
34pub const RADIUS_GROUP: &str = "idm_radius_servers";
36const ENTRY_MANAGER: &str = "idm_admin";
37
38const RADIUS_ACCOUNT_PREFIX: &str = "kaniop_radius_";
39const DISPLAY_NAME_PREFIX: &str = "Kaniop RADIUS: ";
40
41#[derive(Clone, Debug, PartialEq, Eq)]
42pub struct RadiusIdentity {
43 pub account_name: String,
45 pub display_name: String,
47}
48
49#[derive(Debug, Error, PartialEq, Eq)]
50pub enum RadiusIdentityError {
51 #[error("RADIUS resource requires a valid Kubernetes UID")]
52 InvalidUid,
53 #[error("RADIUS resource requires a namespace and a name")]
54 MissingObjectIdentity,
55}
56
57impl RadiusIdentity {
58 pub fn new(namespace: &str, name: &str, uid: &str) -> Result<Self, RadiusIdentityError> {
59 if namespace.is_empty() || name.is_empty() {
60 return Err(RadiusIdentityError::MissingObjectIdentity);
61 }
62 let uid = Uuid::parse_str(uid).map_err(|_| RadiusIdentityError::InvalidUid)?;
63 let account_name = format!("{RADIUS_ACCOUNT_PREFIX}{}", uid.simple());
67 let display_name = format!(
68 "{DISPLAY_NAME_PREFIX}{namespace}/{name} [{}]",
69 uid.hyphenated()
70 );
71 Ok(Self {
72 account_name,
73 display_name,
74 })
75 }
76
77 pub fn matches_existing_display_name(&self, display_name: &str) -> bool {
81 self.display_name == display_name
82 }
83
84 pub fn for_resource(radius: &KanidmRadiusServer) -> Result<Self, RadiusIdentityError> {
86 let namespace = radius
87 .namespace()
88 .ok_or(RadiusIdentityError::MissingObjectIdentity)?;
89 let uid = radius
90 .metadata
91 .uid
92 .as_deref()
93 .ok_or(RadiusIdentityError::InvalidUid)?;
94 Self::new(&namespace, &radius.name_any(), uid)
95 }
96}
97
98#[derive(Clone, Copy, Debug, PartialEq, Eq)]
100pub enum AccountState {
101 Absent,
102 Owned,
104 Foreign,
106}
107
108pub fn account_state(entry: Option<&Entry>, identity: &RadiusIdentity) -> AccountState {
111 match entry {
112 None => AccountState::Absent,
113 Some(entry)
114 if entry.attrs.get("displayname").is_some_and(|names| {
115 names.len() == 1 && identity.matches_existing_display_name(&names[0])
116 }) =>
117 {
118 AccountState::Owned
119 }
120 Some(_) => AccountState::Foreign,
121 }
122}
123
124pub fn is_member(members: &[String], account: &str) -> bool {
126 let wanted = normalize_spn(account);
127 members.iter().any(|member| normalize_spn(member) == wanted)
128}
129
130fn is_conflict(error: &ClientError) -> bool {
131 matches!(error, ClientError::Http(status, _, _) if status.as_u16() == 409)
132}
133
134pub(crate) fn is_not_found(error: &ClientError) -> bool {
136 matches!(error, ClientError::Http(status, _, _) if status.as_u16() == 404)
137 || matches!(
138 error,
139 ClientError::Http(_, Some(OperationError::NoMatchingEntries), _)
140 )
141}
142
143#[derive(Clone, Copy, Debug, PartialEq, Eq)]
145pub struct IdentityOutcome {
146 pub account_created: bool,
147 pub membership_added: bool,
148}
149
150async fn get_account(
151 client: &KanidmClient,
152 metrics: &ControllerMetrics,
153 identity: &RadiusIdentity,
154) -> ExecResult<AccountState> {
155 let entry = sdk::call(
156 metrics,
157 KANIDM_OP_GET,
158 KANIDM_OUTCOME_UNCHANGED,
159 client.idm_service_account_get(&identity.account_name),
160 )
161 .await
162 .map_err(|e| kanidm_error("get", "RADIUS service account", e))?;
163 Ok(account_state(entry.as_ref(), identity))
164}
165
166async fn members(client: &KanidmClient, metrics: &ControllerMetrics) -> ExecResult<Vec<String>> {
167 Ok(sdk::call(
168 metrics,
169 KANIDM_OP_GET,
170 KANIDM_OUTCOME_UNCHANGED,
171 client.idm_group_get_members(RADIUS_GROUP),
172 )
173 .await
174 .map_err(|e| kanidm_error("get members of", RADIUS_GROUP, e))?
175 .unwrap_or_default())
176}
177
178pub async fn ensure_identity(
184 client: &KanidmClient,
185 metrics: &ControllerMetrics,
186 identity: &RadiusIdentity,
187) -> ExecResult<IdentityOutcome> {
188 let name = &identity.account_name;
189 let mut account_created = false;
190 match get_account(client, metrics, identity).await? {
191 AccountState::Owned => {}
192 AccountState::Foreign => return Err(not_owned(identity)),
193 AccountState::Absent => {
194 match sdk::call(
195 metrics,
196 KANIDM_OP_CREATE,
197 KANIDM_OUTCOME_CHANGED,
198 client.idm_service_account_create(name, &identity.display_name, ENTRY_MANAGER),
199 )
200 .await
201 {
202 Ok(()) => account_created = true,
203 Err(error) if is_conflict(&error) => {
206 if get_account(client, metrics, identity).await? != AccountState::Owned {
207 return Err(not_owned(identity));
208 }
209 }
210 Err(error) => {
211 return Err(kanidm_error("create", "RADIUS service account", error));
212 }
213 }
214 }
215 }
216
217 let membership_added = if is_member(&members(client, metrics).await?, name) {
218 false
219 } else {
220 sdk::call(
221 metrics,
222 KANIDM_OP_ADD_MEMBERS,
223 KANIDM_OUTCOME_CHANGED,
224 client.idm_group_add_members(RADIUS_GROUP, &[name.as_str()]),
225 )
226 .await
227 .map_err(|e| kanidm_error("add member to", RADIUS_GROUP, e))?;
228 true
229 };
230 Ok(IdentityOutcome {
231 account_created,
232 membership_added,
233 })
234}
235
236fn not_owned(identity: &RadiusIdentity) -> ExecError {
237 ExecError::AccountNotOwned {
238 account: identity.account_name.clone(),
239 }
240}
241
242#[derive(Clone, Copy, Debug, PartialEq, Eq)]
244pub enum DeleteOutcome {
245 AlreadyAbsent,
247 Deleted,
250}
251
252pub async fn delete_identity(
257 client: &KanidmClient,
258 metrics: &ControllerMetrics,
259 identity: &RadiusIdentity,
260) -> ExecResult<DeleteOutcome> {
261 let name = &identity.account_name;
262 match get_account(client, metrics, identity).await? {
263 AccountState::Absent => return Ok(DeleteOutcome::AlreadyAbsent),
264 AccountState::Foreign => return Err(not_owned(identity)),
265 AccountState::Owned => {}
266 }
267 if is_member(&members(client, metrics).await?, name) {
268 sdk::call(
270 metrics,
271 KANIDM_OP_REMOVE_MEMBERS,
272 KANIDM_OUTCOME_CHANGED,
273 client.idm_group_remove_members(RADIUS_GROUP, &[name.as_str()]),
274 )
275 .await
276 .map_err(|e| kanidm_error("remove member from", RADIUS_GROUP, e))?;
277 }
278 match sdk::call(
279 metrics,
280 KANIDM_OP_DELETE,
281 KANIDM_OUTCOME_CHANGED,
282 client.idm_service_account_delete(name),
283 )
284 .await
285 {
286 Ok(()) => Ok(DeleteOutcome::Deleted),
287 Err(error) if is_not_found(&error) => Ok(DeleteOutcome::AlreadyAbsent),
288 Err(error) => Err(kanidm_error("delete", "RADIUS service account", error)),
289 }
290}
291
292#[cfg(test)]
293mod tests {
294 use super::*;
295
296 const FIRST_UID: &str = "d10066c3-4599-4487-972d-26bb42587a32";
297 const SECOND_UID: &str = "ad8cf3d5-b2a9-44d6-b257-058554ab09d5";
298
299 #[test]
300 fn identity_is_stable_across_reconciliation() {
301 let a = RadiusIdentity::new("network", "radius", FIRST_UID).unwrap();
302 let b = RadiusIdentity::new("network", "radius", FIRST_UID).unwrap();
303 assert_eq!(a, b);
304 assert_eq!(
305 a.account_name,
306 "kaniop_radius_d10066c345994487972d26bb42587a32"
307 );
308 assert!(a.matches_existing_display_name(&a.display_name));
309 }
310
311 #[test]
312 fn same_name_recreated_with_new_uid_does_not_adopt_previous_account() {
313 let old = RadiusIdentity::new("network", "radius", FIRST_UID).unwrap();
314 let new = RadiusIdentity::new("network", "radius", SECOND_UID).unwrap();
315 assert_ne!(old.account_name, new.account_name);
316 assert!(!new.matches_existing_display_name(&old.display_name));
317 }
318
319 #[test]
320 fn different_resources_cannot_share_the_same_uid_identity_marker() {
321 let a = RadiusIdentity::new("network-a", "radius", FIRST_UID).unwrap();
324 let b = RadiusIdentity::new("network-b", "radius", FIRST_UID).unwrap();
325 assert_eq!(a.account_name, b.account_name);
326 assert!(!b.matches_existing_display_name(&a.display_name));
327 }
328
329 #[test]
330 fn rejects_absent_or_non_uuid_uid() {
331 assert_eq!(
332 RadiusIdentity::new("network", "radius", ""),
333 Err(RadiusIdentityError::InvalidUid)
334 );
335 assert_eq!(
336 RadiusIdentity::new("network", "radius", "wrong-uid"),
337 Err(RadiusIdentityError::InvalidUid)
338 );
339 assert_eq!(
340 RadiusIdentity::new("", "radius", FIRST_UID),
341 Err(RadiusIdentityError::MissingObjectIdentity)
342 );
343 }
344
345 #[test]
346 fn forged_display_name_causes_ownership_conflict() {
347 let identity = RadiusIdentity::new("network", "radius", FIRST_UID).unwrap();
348 assert!(!identity.matches_existing_display_name("Someone else's service account"));
349 }
350}
351
352#[cfg(test)]
353mod executor_tests {
354 use std::sync::{Arc, Mutex};
355
356 use serde_json::{Value, json};
357
358 use super::*;
359 use crate::reconcile::kanidm_mock::{self, Request};
360
361 const UID: &str = "d10066c3-4599-4487-972d-26bb42587a32";
362 const ACCOUNT: &str = "kaniop_radius_d10066c345994487972d26bb42587a32";
363 const ACCOUNT_PATH: &str = "/v1/service_account/kaniop_radius_d10066c345994487972d26bb42587a32";
364 const MEMBERS_PATH: &str = "/v1/group/idm_radius_servers/_attr/member";
365
366 fn identity() -> RadiusIdentity {
367 RadiusIdentity::new("network", "campus", UID).unwrap()
368 }
369
370 fn entry_json(display_name: &str) -> String {
371 json!({"attrs": {"displayname": [display_name]}}).to_string()
372 }
373
374 #[derive(Default)]
376 struct World {
377 account: Option<String>,
378 members: Vec<String>,
379 create_conflicts: bool,
380 }
381
382 fn handler(world: Arc<Mutex<World>>) -> impl Fn(&Request) -> (u16, String) + Send + Sync {
383 move |req| {
384 let mut w = world.lock().unwrap();
385 match (req.method.as_str(), req.path.as_str()) {
386 ("GET", ACCOUNT_PATH) => match &w.account {
387 Some(name) => (200, entry_json(name)),
388 None => (200, "null".into()),
389 },
390 ("GET", MEMBERS_PATH) => (200, serde_json::to_string(&w.members).unwrap()),
391 ("POST", "/v1/service_account") => {
392 if w.create_conflicts {
393 return (409, "{}".into());
394 }
395 let body: Value = serde_json::from_str(&req.body).unwrap();
396 w.account = Some(body["attrs"]["displayname"][0].as_str().unwrap().into());
397 (200, "null".into())
398 }
399 ("POST", MEMBERS_PATH) => {
400 let added: Vec<String> = serde_json::from_str(&req.body).unwrap();
401 w.members.extend(added);
402 (200, "null".into())
403 }
404 ("DELETE", MEMBERS_PATH) => {
405 let removed: Vec<String> = serde_json::from_str(&req.body).unwrap();
406 w.members.retain(|m| !removed.contains(m));
407 (200, "null".into())
408 }
409 ("DELETE", ACCOUNT_PATH) => {
410 w.account = None;
411 (200, "null".into())
412 }
413 _ => (500, "{}".into()),
414 }
415 }
416 }
417
418 #[test]
419 fn account_state_requires_the_exact_marker() {
420 let id = identity();
421 let owned: Entry =
422 serde_json::from_value(json!({"attrs": {"displayname": [id.display_name.clone()]}}))
423 .unwrap();
424 assert_eq!(account_state(Some(&owned), &id), AccountState::Owned);
425 assert_eq!(account_state(None, &id), AccountState::Absent);
426 let other: Entry =
427 serde_json::from_value(json!({"attrs": {"displayname": ["Someone else"]}})).unwrap();
428 assert_eq!(account_state(Some(&other), &id), AccountState::Foreign);
429 let none: Entry = serde_json::from_value(json!({"attrs": {}})).unwrap();
430 assert_eq!(account_state(Some(&none), &id), AccountState::Foreign);
431 let two: Entry = serde_json::from_value(
432 json!({"attrs": {"displayname": [id.display_name.clone(), "x"]}}),
433 )
434 .unwrap();
435 assert_eq!(account_state(Some(&two), &id), AccountState::Foreign);
436 }
437
438 #[test]
439 fn membership_matches_names_and_spns() {
440 let members = vec![
441 "other@idm.example.com".to_string(),
442 format!("{ACCOUNT}@idm.example.com"),
443 ];
444 assert!(is_member(&members, ACCOUNT));
445 assert!(!is_member(&members[..1], ACCOUNT));
446 assert!(!is_member(&[], ACCOUNT));
447 }
448
449 #[test]
450 fn identity_for_resource_uses_namespace_name_and_uid() {
451 let radius: KanidmRadiusServer = serde_json::from_value(json!({
452 "apiVersion": "kaniop.rs/v1beta1", "kind": "KanidmRadiusServer",
453 "metadata": {"name": "campus", "namespace": "network", "uid": UID},
454 "spec": {
455 "kanidmRef": {"name": "idm"},
456 "authorization": {"requiredGroups": ["allowed@idm.example.com"]},
457 "clients": [{
458 "name": "nas",
459 "ipaddr": "192.0.2.1",
460 "sharedSecretRef": {"name": "nas-secret", "key": "nas"}
461 }],
462 "radiusTls": {"secretRef": {"name": "radius-tls"}}
463 }
464 }))
465 .unwrap();
466 assert_eq!(RadiusIdentity::for_resource(&radius).unwrap(), identity());
467 let mut no_uid = radius.clone();
468 no_uid.metadata.uid = None;
469 assert_eq!(
470 RadiusIdentity::for_resource(&no_uid),
471 Err(RadiusIdentityError::InvalidUid)
472 );
473 }
474
475 #[tokio::test]
476 async fn ensure_creates_account_and_adds_only_its_own_membership() {
477 let world = Arc::new(Mutex::new(World {
478 members: vec!["unrelated_radius_server".into()],
479 ..Default::default()
480 }));
481 let mock = kanidm_mock::start(handler(world.clone())).await;
482 let outcome = ensure_identity(&mock.client, &mock.metrics, &identity())
483 .await
484 .unwrap();
485 assert_eq!(
486 outcome,
487 IdentityOutcome {
488 account_created: true,
489 membership_added: true
490 }
491 );
492 let w = world.lock().unwrap();
493 assert_eq!(w.account.as_deref(), Some(identity().display_name.as_str()));
494 assert_eq!(w.members, ["unrelated_radius_server", ACCOUNT]);
495 assert!(
497 mock.writes().iter().all(|r| r.method == "POST"
498 && (r.path == "/v1/service_account" || r.path == MEMBERS_PATH))
499 );
500 }
501
502 #[tokio::test]
503 async fn ensure_is_idempotent() {
504 let world = Arc::new(Mutex::new(World {
505 account: Some(identity().display_name),
506 members: vec![ACCOUNT.into()],
507 ..Default::default()
508 }));
509 let mock = kanidm_mock::start(handler(world)).await;
510 let outcome = ensure_identity(&mock.client, &mock.metrics, &identity())
511 .await
512 .unwrap();
513 assert_eq!(
514 outcome,
515 IdentityOutcome {
516 account_created: false,
517 membership_added: false
518 }
519 );
520 assert!(mock.writes().is_empty());
521 }
522
523 #[tokio::test]
524 async fn ensure_never_adopts_a_foreign_account() {
525 let world = Arc::new(Mutex::new(World {
526 account: Some("Hand-made RADIUS account".into()),
527 ..Default::default()
528 }));
529 let mock = kanidm_mock::start(handler(world.clone())).await;
530 let error = ensure_identity(&mock.client, &mock.metrics, &identity())
531 .await
532 .unwrap_err();
533 assert!(matches!(error, ExecError::AccountNotOwned { .. }));
534 assert!(mock.writes().is_empty(), "no update, membership or delete");
535 assert_eq!(
536 world.lock().unwrap().account.as_deref(),
537 Some("Hand-made RADIUS account")
538 );
539 }
540
541 #[tokio::test]
542 async fn ensure_after_a_create_conflict_verifies_the_marker() {
543 let world = Arc::new(Mutex::new(World::default()));
545 let calls = Arc::new(Mutex::new(0));
546 let (w, c) = (world.clone(), calls.clone());
547 let inner = handler(world.clone());
548 let mock = kanidm_mock::start(move |req| {
549 if req.method == "GET" && req.path == ACCOUNT_PATH {
550 let mut n = c.lock().unwrap();
551 *n += 1;
552 if *n == 2 {
553 w.lock().unwrap().account = Some(identity().display_name);
555 }
556 }
557 if req.method == "POST" && req.path == "/v1/service_account" {
558 return (409, "{}".into());
559 }
560 inner(req)
561 })
562 .await;
563 let outcome = ensure_identity(&mock.client, &mock.metrics, &identity())
564 .await
565 .unwrap();
566 assert!(!outcome.account_created);
567 assert!(outcome.membership_added);
568
569 let world = Arc::new(Mutex::new(World {
571 create_conflicts: true,
572 ..Default::default()
573 }));
574 let (w, c) = (world.clone(), Arc::new(Mutex::new(0)));
575 let inner = handler(world);
576 let mock = kanidm_mock::start(move |req| {
577 if req.method == "GET" && req.path == ACCOUNT_PATH {
578 let mut n = c.lock().unwrap();
579 *n += 1;
580 if *n == 2 {
581 w.lock().unwrap().account = Some("Foreign".into());
582 }
583 }
584 inner(req)
585 })
586 .await;
587 assert!(matches!(
588 ensure_identity(&mock.client, &mock.metrics, &identity()).await,
589 Err(ExecError::AccountNotOwned { .. })
590 ));
591 }
592
593 #[tokio::test]
594 async fn delete_removes_only_our_edge_then_the_account() {
595 let world = Arc::new(Mutex::new(World {
596 account: Some(identity().display_name),
597 members: vec!["unrelated_radius_server".into(), ACCOUNT.into()],
598 ..Default::default()
599 }));
600 let mock = kanidm_mock::start(handler(world.clone())).await;
601 assert_eq!(
602 delete_identity(&mock.client, &mock.metrics, &identity())
603 .await
604 .unwrap(),
605 DeleteOutcome::Deleted
606 );
607 let w = world.lock().unwrap();
608 assert!(w.account.is_none());
609 assert_eq!(w.members, ["unrelated_radius_server"]);
610 let writes = mock.writes();
611 assert_eq!(writes[0].path, MEMBERS_PATH);
612 assert_eq!(writes[0].body, format!("[\"{ACCOUNT}\"]"));
613 assert_eq!(writes[1].path, ACCOUNT_PATH);
614 }
615
616 #[tokio::test]
617 async fn delete_absent_account_is_success_and_foreign_is_untouched() {
618 let mock = kanidm_mock::start(handler(Arc::new(Mutex::new(World::default())))).await;
619 assert_eq!(
620 delete_identity(&mock.client, &mock.metrics, &identity())
621 .await
622 .unwrap(),
623 DeleteOutcome::AlreadyAbsent
624 );
625 assert!(mock.writes().is_empty());
626
627 let world = Arc::new(Mutex::new(World {
628 account: Some("Not ours".into()),
629 members: vec![ACCOUNT.into()],
630 ..Default::default()
631 }));
632 let mock = kanidm_mock::start(handler(world.clone())).await;
633 let error = delete_identity(&mock.client, &mock.metrics, &identity())
634 .await
635 .unwrap_err();
636 assert!(matches!(error, ExecError::AccountNotOwned { .. }));
637 assert!(mock.writes().is_empty());
638 assert!(world.lock().unwrap().account.is_some());
639 }
640
641 #[tokio::test]
642 async fn delete_treats_a_vanished_account_as_done() {
643 let world = Arc::new(Mutex::new(World {
644 account: Some(identity().display_name),
645 ..Default::default()
646 }));
647 let inner = handler(world);
648 let mock = kanidm_mock::start(move |req| {
649 if req.method == "DELETE" && req.path == ACCOUNT_PATH {
650 return (404, "\"NoMatchingEntries\"".into());
651 }
652 inner(req)
653 })
654 .await;
655 assert_eq!(
656 delete_identity(&mock.client, &mock.metrics, &identity())
657 .await
658 .unwrap(),
659 DeleteOutcome::AlreadyAbsent
660 );
661 }
662
663 #[tokio::test]
664 async fn kanidm_outage_keeps_its_source() {
665 let mock = kanidm_mock::start(|_| (503, "{}".into())).await;
666 let error = ensure_identity(&mock.client, &mock.metrics, &identity())
667 .await
668 .unwrap_err();
669 assert!(matches!(error, ExecError::Api(_)));
670 }
671}