1use kaniop_k8s_util::types::normalize_spn;
2use kaniop_operator::controller::kanidm::KanidmResource;
3use kaniop_operator::crd::{KanidmRef, SecretRotation, MetadataTemplate};
4use kaniop_operator::kanidm::crd::Kanidm;
5
6use std::{
7 collections::{BTreeSet, HashMap},
8 ops::Not,
9};
10
11use kanidm_proto::internal::Oauth2ClaimMapJoin;
12
13use k8s_openapi::apimachinery::pkg::apis::meta::v1::{Condition, LabelSelector};
14use kube::CustomResource;
15#[cfg(feature = "schemars")]
16use schemars::JsonSchema;
17use serde::{Deserialize, Serialize};
18
19#[derive(CustomResource, Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
26#[cfg_attr(feature = "schemars", derive(JsonSchema))]
27#[kube(
28 category = "kaniop",
29 group = "kaniop.rs",
30 version = "v1beta1",
31 kind = "KanidmOAuth2Client",
32 plural = "kanidmoauth2clients",
33 singular = "kanidmoauth2client",
34 shortname = "oauth2",
35 namespaced,
36 status = "KanidmOAuth2ClientStatus",
37 doc = r#"The Kanidm OAuth2 client custom resource definition (CRD) defines an OAuth2 client
38 integration in Kanidm."#,
39 printcolumn = r#"{"name":"Kanidm","type":"string","jsonPath":".status.kanidmRef"}"#,
40 printcolumn = r#"{"name":"Public","type":"string","jsonPath":".spec.public"}"#,
41 printcolumn = r#"{"name":"Secret","type":"string","jsonPath":".status.secretName"}"#,
42 printcolumn = r#"{"name":"Ready","type":"boolean","jsonPath":".status.ready"}"#,
43 printcolumn = r#"{"name":"Age","type":"date","jsonPath":".metadata.creationTimestamp"}"#,
44 derive = "Default"
45)]
46#[serde(rename_all = "camelCase")]
47pub struct KanidmOAuth2ClientSpec {
48 pub kanidm_ref: KanidmRef,
49
50 #[schemars(extend("x-kubernetes-validations" = [{"message": "kanidmName cannot be changed.", "rule": "self == oldSelf"}]))]
55 #[serde(skip_serializing_if = "Option::is_none")]
56 pub kanidm_name: Option<String>,
57
58 pub displayname: String,
60
61 pub origin: String,
64
65 pub redirect_url: Vec<String>,
67
68 #[schemars(extend("x-kubernetes-validations" = [{"message": "Public cannot be changed.", "rule": "self == oldSelf"}]))]
79 #[serde(default)]
80 pub public: bool,
81
82 #[serde(skip_serializing_if = "Option::is_none")]
85 pub scope_map: Option<BTreeSet<KanidmScopeMap>>,
86
87 #[serde(skip_serializing_if = "Option::is_none")]
94 pub sup_scope_map: Option<BTreeSet<KanidmScopeMap>>,
95
96 #[serde(skip_serializing_if = "Option::is_none")]
98 pub claim_map: Option<BTreeSet<KanidmClaimMap>>,
99
100 #[serde(skip_serializing_if = "Option::is_none")]
105 pub strict_redirect_url: Option<bool>,
106
107 #[serde(skip_serializing_if = "Option::is_none")]
111 pub prefer_short_username: Option<bool>,
112
113 #[serde(skip_serializing_if = "Option::is_none")]
118 pub allow_localhost_redirect: Option<bool>,
119
120 #[serde(skip_serializing_if = "Option::is_none")]
126 pub allow_insecure_client_disable_pkce: Option<bool>,
127
128 #[serde(skip_serializing_if = "Option::is_none")]
134 pub jwt_legacy_crypto_enable: Option<bool>,
135
136 #[serde(skip_serializing_if = "Option::is_none")]
142 pub disable_consent_prompt: Option<bool>,
143
144 #[serde(default, skip_serializing_if = "Option::is_none")]
148 pub secret_rotation: Option<SecretRotation>,
149
150 #[serde(default, skip_serializing_if = "Option::is_none")]
156 pub secret_template: Option<MetadataTemplate>,
157
158 #[serde(default, skip_serializing_if = "Option::is_none")]
163 pub secret_key_aliases: Option<SecretKeyAliases>,
164
165 #[serde(skip_serializing_if = "Option::is_none")]
172 pub image: Option<OAuth2ClientImageSpec>,
173}
174
175#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
176#[cfg_attr(feature = "schemars", derive(JsonSchema))]
177#[serde(rename_all = "camelCase")]
178pub struct OAuth2ClientImageSpec {
179 pub url: String,
183}
184
185#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
189#[cfg_attr(feature = "schemars", derive(JsonSchema))]
190#[serde(rename_all = "camelCase")]
191pub struct SecretKeyAliases {
192 #[serde(default, skip_serializing_if = "Option::is_none")]
195 pub client_id: Option<Vec<String>>,
196
197 #[serde(default, skip_serializing_if = "Option::is_none")]
200 pub client_secret: Option<Vec<String>>,
201}
202
203impl SecretKeyAliases {
204 pub fn collect_aliases(&self) -> (Vec<String>, Vec<String>) {
205 let client_id_aliases = self
206 .client_id
207 .as_ref()
208 .map(|v| {
209 let mut deduped: Vec<String> = v.to_vec();
210 deduped.sort();
211 deduped.dedup();
212 deduped
213 })
214 .unwrap_or_default();
215
216 let client_secret_aliases = self
217 .client_secret
218 .as_ref()
219 .map(|v| {
220 let mut deduped: Vec<String> = v.to_vec();
221 deduped.sort();
222 deduped.dedup();
223 deduped
224 })
225 .unwrap_or_default();
226
227 (client_id_aliases, client_secret_aliases)
228 }
229}
230
231impl KanidmResource for KanidmOAuth2Client {
232 #[inline]
233 fn kanidm_ref_spec(&self) -> &KanidmRef {
234 &self.spec.kanidm_ref
235 }
236
237 #[inline]
238 fn get_namespace_selector(kanidm: &Kanidm) -> &Option<LabelSelector> {
239 &kanidm.spec.oauth2_client_namespace_selector
240 }
241
242 #[inline]
243 fn kanidm_name_override(&self) -> Option<&str> {
244 self.spec.kanidm_name.as_deref()
245 }
246}
247
248#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq, PartialOrd, Eq, Ord)]
258#[cfg_attr(feature = "schemars", derive(JsonSchema))]
259#[serde(rename_all = "camelCase")]
260pub struct KanidmScopeMap {
261 pub group: String,
263
264 #[allow(clippy::doc_overindented_list_items)]
283 pub scopes: Vec<String>,
284}
285
286impl KanidmScopeMap {
287 pub fn normalize(self) -> Self {
288 let mut scopes = self.scopes;
289 scopes.sort();
290 Self {
291 group: normalize_spn(&self.group),
292 scopes,
293 }
294 }
295 pub fn from(s: &str) -> Option<Self> {
296 let parts = s.split(':').collect::<Vec<_>>();
297 if parts.len() != 2 {
298 return None;
299 }
300 let group = parts[0].to_string();
301 let proto_scopes = parts[1];
302 if proto_scopes.starts_with(" {").not() || proto_scopes.ends_with('}').not() {
303 return None;
304 }
305
306 let scopes = proto_scopes[2..proto_scopes.len() - 1]
307 .split(", ")
308 .map(|s| s.replace('"', ""))
309 .collect();
310 Some(Self { group, scopes })
311 }
312}
313
314#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq, PartialOrd, Eq, Ord)]
322#[cfg_attr(feature = "schemars", derive(JsonSchema))]
323#[serde(rename_all = "camelCase")]
324pub struct KanidmClaimMap {
325 pub name: String,
327
328 pub values_map: BTreeSet<KanidmClaimsValuesMap>,
329
330 #[serde(default)]
336 pub join_strategy: KanidmClaimMapJoinStrategy,
337}
338
339impl KanidmClaimMap {
340 pub fn normalize(self) -> Self {
341 Self {
342 values_map: self
343 .values_map
344 .iter()
345 .map(|vm| vm.clone().normalize())
346 .collect(),
347 ..self
348 }
349 }
350
351 pub fn from(s: &str) -> Option<Self> {
352 let parts = s.split(':').collect::<Vec<_>>();
353 if parts.len() != 4 {
354 return None;
355 }
356 let name = parts[0].to_string();
357 let group = parts[1].to_string();
358 let join_strategy = match parts[2] {
359 "," => KanidmClaimMapJoinStrategy::Csv,
360 " " => KanidmClaimMapJoinStrategy::Ssv,
361 ";" => KanidmClaimMapJoinStrategy::Array,
362 _ => return None,
363 };
364 let proto_values = parts[3];
365 if proto_values.starts_with('"').not() || proto_values.ends_with('"').not() {
366 return None;
367 }
368 let values = proto_values[1..proto_values.len() - 1]
369 .split(",")
370 .map(|s| s.to_string())
371 .collect();
372 Some(Self {
373 name,
374 join_strategy,
375 values_map: BTreeSet::from([KanidmClaimsValuesMap { group, values }]),
376 })
377 }
378
379 pub fn group(v: &[KanidmClaimMap]) -> BTreeSet<KanidmClaimMap> {
380 let mut map: HashMap<String, KanidmClaimMap> = HashMap::new();
381
382 for claim in v {
383 if let Some(existing) = map.get_mut(&claim.name) {
384 existing.values_map.extend(claim.values_map.clone());
385 } else {
386 map.insert(claim.name.clone(), claim.clone());
387 }
388 }
389
390 map.into_values().collect()
391 }
392}
393
394#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq, PartialOrd, Eq, Ord)]
395#[cfg_attr(feature = "schemars", derive(JsonSchema))]
396#[serde(rename_all = "camelCase")]
397pub struct KanidmClaimsValuesMap {
398 pub group: String,
400
401 pub values: Vec<String>,
403}
404
405impl KanidmClaimsValuesMap {
406 pub fn normalize(self) -> Self {
407 let mut values = self.values;
408 values.sort();
409 Self {
410 group: normalize_spn(&self.group),
411 values,
412 }
413 }
414}
415
416#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq, PartialOrd, Eq, Ord)]
417#[cfg_attr(feature = "schemars", derive(JsonSchema))]
418#[serde(rename_all = "snake_case")]
419pub enum KanidmClaimMapJoinStrategy {
420 Csv,
422 Ssv,
424 #[default]
426 Array,
427}
428
429impl KanidmClaimMapJoinStrategy {
430 pub fn to_oauth2_claim_map_join(&self) -> Oauth2ClaimMapJoin {
431 match self {
432 KanidmClaimMapJoinStrategy::Csv => Oauth2ClaimMapJoin::Csv,
433 KanidmClaimMapJoinStrategy::Ssv => Oauth2ClaimMapJoin::Ssv,
434 KanidmClaimMapJoinStrategy::Array => Oauth2ClaimMapJoin::Array,
435 }
436 }
437}
438
439#[derive(Serialize, Deserialize, Clone, Debug, Default)]
443#[cfg_attr(feature = "schemars", derive(JsonSchema))]
444#[serde(rename_all = "camelCase")]
445pub struct KanidmOAuth2ClientStatus {
446 #[serde(skip_serializing_if = "Option::is_none")]
447 pub conditions: Option<Vec<Condition>>,
448
449 #[serde(skip_serializing_if = "Option::is_none")]
450 pub origin: Option<Vec<String>>,
451
452 #[serde(skip_serializing_if = "Option::is_none")]
453 pub scope_map: Option<Vec<String>>,
454
455 #[serde(skip_serializing_if = "Option::is_none")]
456 pub sup_scope_map: Option<Vec<String>>,
457
458 #[serde(skip_serializing_if = "Option::is_none")]
459 pub claims_map: Option<Vec<String>>,
460
461 pub ready: bool,
462
463 #[serde(skip_serializing_if = "Option::is_none")]
464 pub secret_name: Option<String>,
465
466 pub kanidm_ref: String,
467
468 #[serde(skip_serializing_if = "Option::is_none")]
470 pub image: Option<OAuth2ClientImageStatus>,
471}
472
473#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
474#[cfg_attr(feature = "schemars", derive(JsonSchema))]
475#[serde(rename_all = "camelCase")]
476pub struct OAuth2ClientImageStatus {
477 pub url: String,
479 #[serde(skip_serializing_if = "Option::is_none")]
481 pub etag: Option<String>,
482 #[serde(skip_serializing_if = "Option::is_none")]
484 pub last_modified: Option<String>,
485 #[serde(skip_serializing_if = "Option::is_none")]
487 pub content_length: Option<u64>,
488 #[serde(skip_serializing_if = "Option::is_none")]
490 pub content_hash: Option<String>,
491}
492
493#[cfg(test)]
494mod tests {
495 use super::{
496 KanidmClaimMap, KanidmClaimMapJoinStrategy, KanidmClaimsValuesMap, KanidmScopeMap,
497 };
498
499 use std::collections::BTreeSet;
500
501 #[test]
502 fn test_kanidm_scope_map_from() {
503 let scope_map = KanidmScopeMap {
504 group: "test_group".to_string(),
505 scopes: vec!["scope1".to_string(), "scope2".to_string()],
506 };
507
508 assert_eq!(
509 KanidmScopeMap::from(r#"test_group@test.example.com: {"scope1", "scope2"}"#)
510 .unwrap()
511 .normalize(),
512 scope_map,
513 );
514
515 assert_eq!(
516 KanidmScopeMap::from(r#"test_group: {"scope1", "scope2"}"#)
517 .unwrap()
518 .normalize(),
519 scope_map,
520 );
521
522 assert!(KanidmScopeMap::from(r#"test_group:{"scope1", "scope2"}"#).is_none(),);
523 assert_eq!(
524 KanidmScopeMap::from(r#"test_group: {"scope1"}"#)
525 .unwrap()
526 .normalize(),
527 KanidmScopeMap {
528 group: "test_group".to_string(),
529 scopes: vec!["scope1".to_string()],
530 }
531 );
532 }
533
534 #[test]
535 fn test_group_kanidm_claims_map() {
536 let claim1 = KanidmClaimMap {
537 name: "claim1".to_string(),
538 values_map: BTreeSet::from([KanidmClaimsValuesMap {
539 group: "group1".to_string(),
540 values: vec!["value1".to_string()],
541 }]),
542 join_strategy: KanidmClaimMapJoinStrategy::Array,
543 };
544
545 let claim2 = KanidmClaimMap {
546 name: "claim1".to_string(),
547 values_map: BTreeSet::from([KanidmClaimsValuesMap {
548 group: "group2".to_string(),
549 values: vec!["value2".to_string()],
550 }]),
551 join_strategy: KanidmClaimMapJoinStrategy::Array,
552 };
553
554 let claim3 = KanidmClaimMap {
555 name: "claim2".to_string(),
556 values_map: BTreeSet::from([KanidmClaimsValuesMap {
557 group: "group3".to_string(),
558 values: vec!["value3".to_string()],
559 }]),
560 join_strategy: KanidmClaimMapJoinStrategy::Array,
561 };
562
563 let claims = vec![claim1.clone(), claim2.clone(), claim3.clone()];
564
565 let grouped_claims = KanidmClaimMap::group(&claims);
566
567 assert_eq!(grouped_claims.len(), 2);
568
569 let grouped_claim1 = grouped_claims.iter().find(|c| c.name == "claim1").unwrap();
570 assert_eq!(grouped_claim1.values_map.len(), 2);
571 assert!(grouped_claim1.values_map.contains(&KanidmClaimsValuesMap {
572 group: "group1".to_string(),
573 values: vec!["value1".to_string()],
574 }));
575 assert!(grouped_claim1.values_map.contains(&KanidmClaimsValuesMap {
576 group: "group2".to_string(),
577 values: vec!["value2".to_string()],
578 }));
579
580 let grouped_claim2 = grouped_claims.iter().find(|c| c.name == "claim2").unwrap();
581 assert_eq!(grouped_claim2.values_map.len(), 1);
582 assert!(grouped_claim2.values_map.contains(&KanidmClaimsValuesMap {
583 group: "group3".to_string(),
584 values: vec!["value3".to_string()],
585 }));
586 }
587
588 #[test]
589 fn test_kanidm_claim_map_from() {
590 let mut claim_map = KanidmClaimMap {
591 name: "claim_name".to_string(),
592 join_strategy: KanidmClaimMapJoinStrategy::Array,
593 values_map: BTreeSet::from([KanidmClaimsValuesMap {
594 group: "group_name".to_string(),
595 values: vec!["boo".to_string(), "foo".to_string()],
597 }]),
598 };
599
600 assert_eq!(
601 KanidmClaimMap::from(r#"claim_name:group_name@test.example.com:;:"foo,boo""#)
602 .unwrap()
603 .normalize(),
604 claim_map,
605 );
606 assert_eq!(
607 KanidmClaimMap::from(r#"claim_name:group_name:;:"foo,boo""#)
608 .unwrap()
609 .normalize(),
610 claim_map,
611 );
612
613 claim_map.join_strategy = KanidmClaimMapJoinStrategy::Csv;
614 assert_eq!(
615 KanidmClaimMap::from(r#"claim_name:group_name:,:"foo,boo""#)
616 .unwrap()
617 .normalize(),
618 claim_map,
619 );
620
621 claim_map.join_strategy = KanidmClaimMapJoinStrategy::Ssv;
622 assert_eq!(
623 KanidmClaimMap::from(r#"claim_name:group_name: :"foo,boo""#)
624 .unwrap()
625 .normalize(),
626 claim_map,
627 );
628 }
629}