1use std::collections::BTreeMap;
8
9use k8s_openapi::api::core::v1::{
10 Affinity, ResourceRequirements, Toleration, TopologySpreadConstraint,
11};
12use k8s_openapi::apimachinery::pkg::apis::meta::v1::{Condition, LabelSelector, Time};
13use kube::CustomResource;
14#[cfg(feature = "schemars")]
15use schemars::JsonSchema;
16use kaniop_operator::controller::kanidm::KanidmResource;
17use kaniop_operator::crd::{KanidmRef, SecretRotation};
18use kaniop_operator::kanidm::crd::Kanidm;
19use serde::{Deserialize, Serialize};
20
21#[derive(CustomResource, Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
27#[cfg_attr(feature = "schemars", derive(JsonSchema))]
28#[kube(
29 category = "kaniop",
30 group = "kaniop.rs",
31 version = "v1beta1",
32 kind = "KanidmRadiusServer",
33 plural = "kanidmradiusservers",
34 singular = "kanidmradiusserver",
35 shortname = "krs",
36 namespaced,
37 status = "KanidmRadiusServerStatus",
38 printcolumn = r#"{"name":"Kanidm","type":"string","jsonPath":".spec.kanidmRef.name"}"#,
39 printcolumn = r#"{"name":"Ready","type":"boolean","jsonPath":".status.ready"}"#,
40 printcolumn = r#"{"name":"Endpoint","type":"string","jsonPath":".status.endpoint"}"#,
41 printcolumn = r#"{"name":"Age","type":"date","jsonPath":".metadata.creationTimestamp"}"#,
42 validation = Rule::new("size(self.metadata.name) <= 52")
43 .message("RADIUS server name must be at most 52 characters"),
44 derive = "Default"
45)]
46#[serde(rename_all = "camelCase")]
47pub struct KanidmRadiusServerSpec {
48 pub kanidm_ref: KanidmRef,
51
52 #[serde(skip_serializing_if = "Option::is_none")]
56 pub image: Option<String>,
57
58 #[serde(default = "default_replicas")]
60 #[schemars(extend("x-kubernetes-validations" = [{"message": "RADIUS replicas must be between 1 and 100", "rule": "self >= 1 && self <= 100"}]))]
61 pub replicas: i32,
62
63 pub authorization: RadiusAuthorizationSpec,
66
67 #[schemars(extend("x-kubernetes-validations" = [{"message": "At least one RADIUS NAS client is required", "rule": "self.size() > 0 && self.size() <= 100"}]))]
70 #[schemars(length(max = 100))]
72 pub clients: Vec<RadiusClientSpec>,
73
74 pub radius_tls: RadiusTlsSpec,
76
77 #[serde(skip_serializing_if = "Option::is_none")]
80 pub kanidm_tls: Option<KanidmTlsSpec>,
81
82 #[serde(default)]
84 pub service: RadiusServiceSpec,
85
86 #[serde(default)]
90 pub token_rotation: SecretRotation,
91
92 #[serde(skip_serializing_if = "Option::is_none")]
94 pub resources: Option<ResourceRequirements>,
95
96 #[serde(skip_serializing_if = "Option::is_none")]
98 pub node_selector: Option<BTreeMap<String, String>>,
99
100 #[serde(skip_serializing_if = "Option::is_none")]
101 pub affinity: Option<Affinity>,
102
103 #[serde(skip_serializing_if = "Option::is_none")]
104 pub tolerations: Option<Vec<Toleration>>,
105
106 #[serde(skip_serializing_if = "Option::is_none")]
107 pub topology_spread_constraints: Option<Vec<TopologySpreadConstraint>>,
108}
109
110fn default_replicas() -> i32 {
111 2
112}
113
114impl KanidmResource for KanidmRadiusServer {
115 fn kanidm_ref_spec(&self) -> &KanidmRef {
116 &self.spec.kanidm_ref
117 }
118
119 fn get_namespace_selector(kanidm: &Kanidm) -> &Option<LabelSelector> {
120 &kanidm.spec.radius_server_namespace_selector
121 }
122
123 fn kanidm_name_override(&self) -> Option<&str> {
124 None
125 }
126}
127
128#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
129#[cfg_attr(feature = "schemars", derive(JsonSchema))]
130#[serde(rename_all = "camelCase")]
131pub struct RadiusAuthorizationSpec {
132 #[schemars(extend("x-kubernetes-validations" = [{"message": "At least one RADIUS authorization group is required", "rule": "self.size() > 0 && self.size() <= 100"}]))]
134 #[schemars(length(max = 100), inner(length(max = 253)))]
137 pub required_groups: Vec<String>,
138
139 #[serde(default = "default_vlan")]
141 #[schemars(extend("x-kubernetes-validations" = [{"message": "RADIUS default VLAN must be in 1..4094", "rule": "self >= 1 && self <= 4094"}]))]
142 pub default_vlan: i32,
143
144 #[schemars(length(max = 100))]
147 #[serde(default, skip_serializing_if = "Vec::is_empty")]
148 pub group_vlans: Vec<RadiusGroupVlan>,
149}
150
151fn default_vlan() -> i32 {
152 1
153}
154
155#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
156#[cfg_attr(feature = "schemars", derive(JsonSchema))]
157#[serde(rename_all = "camelCase")]
158pub struct RadiusGroupVlan {
159 #[schemars(length(max = 253))]
161 pub group: String,
162 #[schemars(extend("x-kubernetes-validations" = [{"message": "RADIUS VLAN must be in 1..4094", "rule": "self >= 1 && self <= 4094"}]))]
163 pub vlan: i32,
164}
165
166#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
167#[cfg_attr(feature = "schemars", derive(JsonSchema))]
168#[serde(rename_all = "camelCase", deny_unknown_fields)]
169pub struct RadiusClientSpec {
170 #[schemars(length(max = 63))]
173 #[schemars(extend("x-kubernetes-validations" = [{"message": "RADIUS NAS client name must be a safe FreeRADIUS identifier", "rule": "self.matches(r'^[A-Za-z0-9_-]{1,63}$')"}]))]
174 pub name: String,
175
176 pub ipaddr: String,
178
179 pub shared_secret_ref: RadiusSecretKeyRef,
182}
183
184#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
185#[cfg_attr(feature = "schemars", derive(JsonSchema))]
186#[serde(rename_all = "camelCase", deny_unknown_fields)]
187pub struct RadiusSecretKeyRef {
188 pub name: String,
189 pub key: String,
190}
191
192#[derive(Serialize, Deserialize, Clone, Copy, Debug, Default, PartialEq, Eq)]
195#[cfg_attr(feature = "schemars", derive(JsonSchema))]
196#[serde(rename_all = "PascalCase")]
197pub enum RadiusCaKind {
198 #[default]
199 ConfigMap,
200 Secret,
201}
202
203#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq, Eq)]
206#[cfg_attr(feature = "schemars", derive(JsonSchema))]
207#[serde(rename_all = "camelCase", deny_unknown_fields)]
208pub struct RadiusCaBundleRef {
209 #[serde(default)]
211 pub kind: RadiusCaKind,
212 pub name: String,
214 pub key: String,
216}
217
218#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
219#[cfg_attr(feature = "schemars", derive(JsonSchema))]
220#[serde(rename_all = "camelCase")]
221pub struct KanidmTlsSpec {
222 #[serde(skip_serializing_if = "Option::is_none")]
225 pub ca_bundle_ref: Option<RadiusCaBundleRef>,
226}
227
228#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
229#[cfg_attr(feature = "schemars", derive(JsonSchema))]
230#[serde(rename_all = "camelCase")]
231pub struct RadiusSecretRef {
232 pub name: String,
233}
234
235#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
236#[cfg_attr(feature = "schemars", derive(JsonSchema))]
237#[serde(rename_all = "camelCase")]
238pub struct RadiusTlsSpec {
239 pub secret_ref: RadiusSecretRef,
241
242 #[serde(default = "default_cert_key")]
244 pub cert_key: String,
245
246 #[serde(default = "default_private_key")]
248 pub private_key_key: String,
249
250 #[serde(skip_serializing_if = "Option::is_none")]
252 pub ca_key: Option<String>,
253}
254
255fn default_cert_key() -> String {
256 "tls.crt".into()
257}
258
259fn default_private_key() -> String {
260 "tls.key".into()
261}
262
263#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
264#[cfg_attr(feature = "schemars", derive(JsonSchema))]
265#[serde(rename_all = "camelCase")]
266#[cfg_attr(feature = "schemars", schemars(extend("x-kubernetes-validations" = [{"message": "RADIUS externalTrafficPolicy is only allowed for NodePort and LoadBalancer Services", "rule": "(has(self.type) ? self.type : 'ClusterIP') != 'ClusterIP' || !has(self.externalTrafficPolicy)"}])))]
267pub struct RadiusServiceSpec {
268 #[serde(rename = "type", default = "default_service_type")]
270 #[schemars(extend("x-kubernetes-validations" = [{"message": "RADIUS Service must be ClusterIP, NodePort or LoadBalancer", "rule": "self in ['ClusterIP','NodePort','LoadBalancer']"}]))]
271 pub type_: String,
272
273 #[serde(default = "default_service_port")]
275 #[schemars(extend("x-kubernetes-validations" = [{"message": "RADIUS UDP port must be 1..65535", "rule": "self >= 1 && self <= 65535"}]))]
276 pub port: i32,
277
278 #[serde(skip_serializing_if = "Option::is_none")]
281 #[schemars(extend("x-kubernetes-validations" = [{"message": "RADIUS externalTrafficPolicy must be Cluster or Local", "rule": "self in ['Cluster','Local']"}]))]
282 pub external_traffic_policy: Option<String>,
283
284 #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
286 pub annotations: BTreeMap<String, String>,
287}
288
289impl Default for RadiusServiceSpec {
290 fn default() -> Self {
291 Self {
292 type_: default_service_type(),
293 port: default_service_port(),
294 external_traffic_policy: None,
295 annotations: BTreeMap::new(),
296 }
297 }
298}
299
300fn default_service_type() -> String {
301 "ClusterIP".into()
302}
303
304fn default_service_port() -> i32 {
305 1812
306}
307
308#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
314#[cfg_attr(feature = "schemars", derive(JsonSchema))]
315#[serde(rename_all = "camelCase")]
316pub struct KanidmRadiusServerStatus {
317 #[serde(default, skip_serializing_if = "Option::is_none")]
320 #[cfg_attr(
321 feature = "schemars",
322 schemars(extend("x-kubernetes-list-type" = "map", "x-kubernetes-list-map-keys" = ["type"]))
323 )]
324 pub conditions: Option<Vec<Condition>>,
325
326 #[serde(default)]
329 pub ready: bool,
330
331 #[serde(skip_serializing_if = "Option::is_none")]
332 pub observed_generation: Option<i64>,
333
334 #[serde(skip_serializing_if = "Option::is_none")]
339 pub endpoint: Option<String>,
340
341 #[serde(skip_serializing_if = "Option::is_none")]
343 pub token_id: Option<String>,
344
345 #[serde(skip_serializing_if = "Option::is_none")]
347 pub token_issued_at: Option<Time>,
348
349 #[serde(skip_serializing_if = "Option::is_none")]
351 pub config_secret_name: Option<String>,
352
353 #[serde(skip_serializing_if = "Option::is_none")]
354 pub deployment_name: Option<String>,
355
356 #[serde(skip_serializing_if = "Option::is_none")]
357 pub service_name: Option<String>,
358
359 #[serde(skip_serializing_if = "Option::is_none")]
361 pub replicas: Option<i32>,
362
363 #[serde(skip_serializing_if = "Option::is_none")]
364 pub ready_replicas: Option<i32>,
365
366 #[serde(default, skip_serializing_if = "Vec::is_empty")]
369 pub retiring_token_ids: Vec<String>,
370}
371
372#[cfg(test)]
373mod tests {
374 use super::*;
375
376 #[test]
377 fn defaults_are_explicit_and_are_not_permissive() {
378 assert_eq!(RadiusServiceSpec::default().type_, "ClusterIP");
379 assert_eq!(RadiusServiceSpec::default().port, 1812);
380 assert!(!SecretRotation::default().enabled);
381 assert_eq!(SecretRotation::default().period_days, 90);
382 let spec: KanidmRadiusServerSpec = serde_json::from_value(serde_json::json!({
383 "kanidmRef": {"name": "idm"},
384 "authorization": {"requiredGroups": ["allowed@idm.example.com"]},
385 "clients": [{"name": "nas", "ipaddr": "192.0.2.1", "sharedSecretRef": {"name": "nas-secret", "key": "nas"}}],
386 "radiusTls": {"secretRef": {"name": "eap-tls"}}
387 })).unwrap();
388 assert_eq!(spec.token_rotation.period_days, 90);
389 assert_eq!(default_replicas(), 2);
390 }
391
392 #[test]
393 fn nas_secrets_are_references_only() {
394 let value: RadiusClientSpec = serde_json::from_value(serde_json::json!({
395 "name": "mikrotik",
396 "ipaddr": "192.0.2.10",
397 "sharedSecretRef": {"name": "nas-credentials", "key": "mikrotik"}
398 }))
399 .unwrap();
400 assert_eq!(value.shared_secret_ref.name, "nas-credentials");
401 let serialized = serde_json::to_string(&value).unwrap();
402 assert!(!serialized.contains("sharedSecret\""));
403 assert!(serialized.contains("sharedSecretRef"));
404 let raw_secret = serde_json::json!({
405 "name": "mikrotik",
406 "ipaddr": "192.0.2.10",
407 "sharedSecret": "do-not-store-this",
408 "sharedSecretRef": {"name": "nas-credentials", "key": "mikrotik"}
409 });
410 assert!(serde_json::from_value::<RadiusClientSpec>(raw_secret).is_err());
411 }
412
413 #[test]
414 fn kanidm_ca_ref_kind_defaults_to_config_map_and_supports_secret() {
415 let implicit: RadiusCaBundleRef = serde_json::from_value(serde_json::json!({
416 "name": "kanidm-ca", "key": "ca.crt"
417 }))
418 .unwrap();
419 assert_eq!(implicit.kind, RadiusCaKind::ConfigMap);
420 let serialized = serde_json::to_value(&implicit).unwrap();
423 assert_eq!(serialized["kind"], "ConfigMap");
424
425 let explicit: RadiusCaBundleRef = serde_json::from_value(serde_json::json!({
426 "kind": "Secret", "name": "private-ca", "key": "ca.crt"
427 }))
428 .unwrap();
429 assert_eq!(explicit.kind, RadiusCaKind::Secret);
430 assert_eq!(serde_json::to_value(&explicit).unwrap()["kind"], "Secret");
431 assert!(
432 serde_json::from_value::<RadiusCaBundleRef>(serde_json::json!({
433 "kind": "Pod", "name": "bad", "key": "ca.crt"
434 }))
435 .is_err()
436 );
437 }
438
439 #[test]
440 fn status_reports_token_ids_and_round_trips() {
441 let status = KanidmRadiusServerStatus {
442 token_id: Some("9ad74e68-147f-49e8-96db-dc21c920ff3b".into()),
443 config_secret_name: Some("campus-0123456789".into()),
444 retiring_token_ids: vec!["31b30b65-037a-418f-b7ca-0c376da2db28".into()],
445 ..Default::default()
446 };
447 let value = serde_json::to_value(&status).unwrap();
448 assert_eq!(value["tokenId"], "9ad74e68-147f-49e8-96db-dc21c920ff3b");
449 assert_eq!(value["configSecretName"], "campus-0123456789");
450 let empty = serde_json::to_value(KanidmRadiusServerStatus::default()).unwrap();
452 assert!(empty.get("retiringTokenIds").is_none());
453 let restored: KanidmRadiusServerStatus = serde_json::from_value(value).unwrap();
454 assert_eq!(restored, status);
455 }
456
457 #[cfg(feature = "schemars")]
458 #[test]
459 fn conditions_have_map_list_schema_and_refs_are_immutable() {
460 use kube::CustomResourceExt;
461
462 let crd = KanidmRadiusServer::crd();
463 let schema = serde_json::to_value(&crd).unwrap();
466 assert_eq!(
467 schema.pointer("/spec/versions/0/schema/openAPIV3Schema/properties/spec/properties/tokenRotation/default/periodDays"),
468 Some(&serde_json::json!(90))
469 );
470 let json = serde_json::to_string(&crd).unwrap();
471 assert!(json.contains("x-kubernetes-list-type"));
472 assert!(json.contains("x-kubernetes-list-map-keys"));
473 assert!(json.contains("Value is immutable"));
474 assert!(json.contains("At least one RADIUS NAS client is required"));
475 assert!(json.contains("At least one RADIUS authorization group is required"));
476 assert!(json.contains("RADIUS default VLAN must be in 1..4094"));
477 assert!(json.contains("RADIUS NAS client name must be a safe FreeRADIUS identifier"));
478 }
479
480 #[cfg(feature = "schemars")]
481 #[test]
482 fn cel_validated_lists_and_strings_are_bounded() {
483 use kube::CustomResourceExt;
484
485 let schema = serde_json::to_value(KanidmRadiusServer::crd()).unwrap();
488 let spec = "/spec/versions/0/schema/openAPIV3Schema/properties/spec/properties";
489 let at = |path: &str| schema.pointer(&format!("{spec}/{path}")).cloned();
490
491 for list in [
492 "clients",
493 "authorization/properties/requiredGroups",
494 "authorization/properties/groupVlans",
495 ] {
496 assert_eq!(
497 at(&format!("{list}/maxItems")),
498 Some(serde_json::json!(100)),
499 "{list} must define maxItems"
500 );
501 }
502 assert_eq!(
503 at("clients/items/properties/name/maxLength"),
504 Some(serde_json::json!(63))
505 );
506 assert_eq!(
507 at("authorization/properties/requiredGroups/items/maxLength"),
508 Some(serde_json::json!(253))
509 );
510 assert_eq!(
511 at("authorization/properties/groupVlans/items/properties/group/maxLength"),
512 Some(serde_json::json!(253))
513 );
514 }
515
516 #[cfg(feature = "schemars")]
517 #[test]
518 fn name_length_rule_matches_the_generated_name_limit() {
519 use kube::CustomResourceExt;
520
521 let value = serde_json::to_value(KanidmRadiusServer::crd()).unwrap();
522 let rules = value
523 .pointer("/spec/versions/0/schema/openAPIV3Schema/x-kubernetes-validations")
524 .and_then(|rules| rules.as_array())
525 .expect("root x-kubernetes-validations");
526 let max = crate::reconcile::workload::MAX_RADIUS_NAME_LEN;
527 assert!(
528 rules
529 .iter()
530 .any(|rule| rule["rule"] == format!("size(self.metadata.name) <= {max}")),
531 "{rules:?}"
532 );
533 }
534
535 #[cfg(feature = "schemars")]
536 #[test]
537 fn service_rule_rejects_external_traffic_policy_on_cluster_ip() {
538 use kube::CustomResourceExt;
539
540 let value = serde_json::to_value(KanidmRadiusServer::crd()).unwrap();
541 let service = value
542 .pointer("/spec/versions/0/schema/openAPIV3Schema/properties/spec/properties/service")
543 .expect("service schema");
544 let rules = service["x-kubernetes-validations"]
545 .as_array()
546 .expect("service x-kubernetes-validations");
547 assert!(
549 rules.iter().any(|rule| rule["rule"]
550 == "(has(self.type) ? self.type : 'ClusterIP') != 'ClusterIP' || !has(self.externalTrafficPolicy)"
551 && rule["message"]
552 .as_str()
553 .is_some_and(|m| m.contains("only allowed for NodePort and LoadBalancer"))),
554 "{rules:?}"
555 );
556 assert_eq!(service["properties"]["type"]["default"], "ClusterIP");
557 }
558
559 #[cfg(feature = "schemars")]
560 #[test]
561 fn print_columns_show_readiness_and_endpoint() {
562 use kube::CustomResourceExt;
563
564 let value = serde_json::to_value(KanidmRadiusServer::crd()).unwrap();
565 let columns = value
566 .pointer("/spec/versions/0/additionalPrinterColumns")
567 .and_then(|columns| columns.as_array())
568 .unwrap();
569 let names: Vec<_> = columns
570 .iter()
571 .map(|column| column["name"].as_str().unwrap())
572 .collect();
573 assert_eq!(names, ["Kanidm", "Ready", "Endpoint", "Age"]);
574 let status = KanidmRadiusServerStatus {
575 endpoint: Some("10.0.0.1:1812".into()),
576 ..Default::default()
577 };
578 assert_eq!(
579 serde_json::to_value(status).unwrap()["endpoint"],
580 "10.0.0.1:1812"
581 );
582 }
583}