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(skip_serializing_if = "Option::is_none")]
165 pub image: Option<OAuth2ClientImageSpec>,
166}
167
168#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
169#[cfg_attr(feature = "schemars", derive(JsonSchema))]
170#[serde(rename_all = "camelCase")]
171pub struct OAuth2ClientImageSpec {
172 pub url: String,
176}
177
178impl KanidmResource for KanidmOAuth2Client {
179 #[inline]
180 fn kanidm_ref_spec(&self) -> &KanidmRef {
181 &self.spec.kanidm_ref
182 }
183
184 #[inline]
185 fn get_namespace_selector(kanidm: &Kanidm) -> &Option<LabelSelector> {
186 &kanidm.spec.oauth2_client_namespace_selector
187 }
188
189 #[inline]
190 fn kanidm_name_override(&self) -> Option<&str> {
191 self.spec.kanidm_name.as_deref()
192 }
193}
194
195#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq, PartialOrd, Eq, Ord)]
205#[cfg_attr(feature = "schemars", derive(JsonSchema))]
206#[serde(rename_all = "camelCase")]
207pub struct KanidmScopeMap {
208 pub group: String,
210
211 #[allow(clippy::doc_overindented_list_items)]
230 pub scopes: Vec<String>,
231}
232
233impl KanidmScopeMap {
234 pub fn normalize(self) -> Self {
235 let mut scopes = self.scopes;
236 scopes.sort();
237 Self {
238 group: normalize_spn(&self.group),
239 scopes,
240 }
241 }
242 pub fn from(s: &str) -> Option<Self> {
243 let parts = s.split(':').collect::<Vec<_>>();
244 if parts.len() != 2 {
245 return None;
246 }
247 let group = parts[0].to_string();
248 let proto_scopes = parts[1];
249 if proto_scopes.starts_with(" {").not() || proto_scopes.ends_with('}').not() {
250 return None;
251 }
252
253 let scopes = proto_scopes[2..proto_scopes.len() - 1]
254 .split(", ")
255 .map(|s| s.replace('"', ""))
256 .collect();
257 Some(Self { group, scopes })
258 }
259}
260
261#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq, PartialOrd, Eq, Ord)]
269#[cfg_attr(feature = "schemars", derive(JsonSchema))]
270#[serde(rename_all = "camelCase")]
271pub struct KanidmClaimMap {
272 pub name: String,
274
275 pub values_map: BTreeSet<KanidmClaimsValuesMap>,
276
277 #[serde(default)]
283 pub join_strategy: KanidmClaimMapJoinStrategy,
284}
285
286impl KanidmClaimMap {
287 pub fn normalize(self) -> Self {
288 Self {
289 values_map: self
290 .values_map
291 .iter()
292 .map(|vm| vm.clone().normalize())
293 .collect(),
294 ..self
295 }
296 }
297
298 pub fn from(s: &str) -> Option<Self> {
299 let parts = s.split(':').collect::<Vec<_>>();
300 if parts.len() != 4 {
301 return None;
302 }
303 let name = parts[0].to_string();
304 let group = parts[1].to_string();
305 let join_strategy = match parts[2] {
306 "," => KanidmClaimMapJoinStrategy::Csv,
307 " " => KanidmClaimMapJoinStrategy::Ssv,
308 ";" => KanidmClaimMapJoinStrategy::Array,
309 _ => return None,
310 };
311 let proto_values = parts[3];
312 if proto_values.starts_with('"').not() || proto_values.ends_with('"').not() {
313 return None;
314 }
315 let values = proto_values[1..proto_values.len() - 1]
316 .split(",")
317 .map(|s| s.to_string())
318 .collect();
319 Some(Self {
320 name,
321 join_strategy,
322 values_map: BTreeSet::from([KanidmClaimsValuesMap { group, values }]),
323 })
324 }
325
326 pub fn group(v: &[KanidmClaimMap]) -> BTreeSet<KanidmClaimMap> {
327 let mut map: HashMap<String, KanidmClaimMap> = HashMap::new();
328
329 for claim in v {
330 if let Some(existing) = map.get_mut(&claim.name) {
331 existing.values_map.extend(claim.values_map.clone());
332 } else {
333 map.insert(claim.name.clone(), claim.clone());
334 }
335 }
336
337 map.into_values().collect()
338 }
339}
340
341#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq, PartialOrd, Eq, Ord)]
342#[cfg_attr(feature = "schemars", derive(JsonSchema))]
343#[serde(rename_all = "camelCase")]
344pub struct KanidmClaimsValuesMap {
345 pub group: String,
347
348 pub values: Vec<String>,
350}
351
352impl KanidmClaimsValuesMap {
353 pub fn normalize(self) -> Self {
354 let mut values = self.values;
355 values.sort();
356 Self {
357 group: normalize_spn(&self.group),
358 values,
359 }
360 }
361}
362
363#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq, PartialOrd, Eq, Ord)]
364#[cfg_attr(feature = "schemars", derive(JsonSchema))]
365#[serde(rename_all = "snake_case")]
366pub enum KanidmClaimMapJoinStrategy {
367 Csv,
369 Ssv,
371 #[default]
373 Array,
374}
375
376impl KanidmClaimMapJoinStrategy {
377 pub fn to_oauth2_claim_map_join(&self) -> Oauth2ClaimMapJoin {
378 match self {
379 KanidmClaimMapJoinStrategy::Csv => Oauth2ClaimMapJoin::Csv,
380 KanidmClaimMapJoinStrategy::Ssv => Oauth2ClaimMapJoin::Ssv,
381 KanidmClaimMapJoinStrategy::Array => Oauth2ClaimMapJoin::Array,
382 }
383 }
384}
385
386#[derive(Serialize, Deserialize, Clone, Debug, Default)]
390#[cfg_attr(feature = "schemars", derive(JsonSchema))]
391#[serde(rename_all = "camelCase")]
392pub struct KanidmOAuth2ClientStatus {
393 #[serde(skip_serializing_if = "Option::is_none")]
394 pub conditions: Option<Vec<Condition>>,
395
396 #[serde(skip_serializing_if = "Option::is_none")]
397 pub origin: Option<Vec<String>>,
398
399 #[serde(skip_serializing_if = "Option::is_none")]
400 pub scope_map: Option<Vec<String>>,
401
402 #[serde(skip_serializing_if = "Option::is_none")]
403 pub sup_scope_map: Option<Vec<String>>,
404
405 #[serde(skip_serializing_if = "Option::is_none")]
406 pub claims_map: Option<Vec<String>>,
407
408 pub ready: bool,
409
410 #[serde(skip_serializing_if = "Option::is_none")]
411 pub secret_name: Option<String>,
412
413 pub kanidm_ref: String,
414
415 #[serde(skip_serializing_if = "Option::is_none")]
417 pub image: Option<OAuth2ClientImageStatus>,
418}
419
420#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
421#[cfg_attr(feature = "schemars", derive(JsonSchema))]
422#[serde(rename_all = "camelCase")]
423pub struct OAuth2ClientImageStatus {
424 pub url: String,
426 #[serde(skip_serializing_if = "Option::is_none")]
428 pub etag: Option<String>,
429 #[serde(skip_serializing_if = "Option::is_none")]
431 pub last_modified: Option<String>,
432 #[serde(skip_serializing_if = "Option::is_none")]
434 pub content_length: Option<u64>,
435 #[serde(skip_serializing_if = "Option::is_none")]
437 pub content_hash: Option<String>,
438}
439
440#[cfg(test)]
441mod tests {
442 use super::{
443 KanidmClaimMap, KanidmClaimMapJoinStrategy, KanidmClaimsValuesMap, KanidmScopeMap,
444 };
445
446 use std::collections::BTreeSet;
447
448 #[test]
449 fn test_kanidm_scope_map_from() {
450 let scope_map = KanidmScopeMap {
451 group: "test_group".to_string(),
452 scopes: vec!["scope1".to_string(), "scope2".to_string()],
453 };
454
455 assert_eq!(
456 KanidmScopeMap::from(r#"test_group@test.example.com: {"scope1", "scope2"}"#)
457 .unwrap()
458 .normalize(),
459 scope_map,
460 );
461
462 assert_eq!(
463 KanidmScopeMap::from(r#"test_group: {"scope1", "scope2"}"#)
464 .unwrap()
465 .normalize(),
466 scope_map,
467 );
468
469 assert!(KanidmScopeMap::from(r#"test_group:{"scope1", "scope2"}"#).is_none(),);
470 assert_eq!(
471 KanidmScopeMap::from(r#"test_group: {"scope1"}"#)
472 .unwrap()
473 .normalize(),
474 KanidmScopeMap {
475 group: "test_group".to_string(),
476 scopes: vec!["scope1".to_string()],
477 }
478 );
479 }
480
481 #[test]
482 fn test_group_kanidm_claims_map() {
483 let claim1 = KanidmClaimMap {
484 name: "claim1".to_string(),
485 values_map: BTreeSet::from([KanidmClaimsValuesMap {
486 group: "group1".to_string(),
487 values: vec!["value1".to_string()],
488 }]),
489 join_strategy: KanidmClaimMapJoinStrategy::Array,
490 };
491
492 let claim2 = KanidmClaimMap {
493 name: "claim1".to_string(),
494 values_map: BTreeSet::from([KanidmClaimsValuesMap {
495 group: "group2".to_string(),
496 values: vec!["value2".to_string()],
497 }]),
498 join_strategy: KanidmClaimMapJoinStrategy::Array,
499 };
500
501 let claim3 = KanidmClaimMap {
502 name: "claim2".to_string(),
503 values_map: BTreeSet::from([KanidmClaimsValuesMap {
504 group: "group3".to_string(),
505 values: vec!["value3".to_string()],
506 }]),
507 join_strategy: KanidmClaimMapJoinStrategy::Array,
508 };
509
510 let claims = vec![claim1.clone(), claim2.clone(), claim3.clone()];
511
512 let grouped_claims = KanidmClaimMap::group(&claims);
513
514 assert_eq!(grouped_claims.len(), 2);
515
516 let grouped_claim1 = grouped_claims.iter().find(|c| c.name == "claim1").unwrap();
517 assert_eq!(grouped_claim1.values_map.len(), 2);
518 assert!(grouped_claim1.values_map.contains(&KanidmClaimsValuesMap {
519 group: "group1".to_string(),
520 values: vec!["value1".to_string()],
521 }));
522 assert!(grouped_claim1.values_map.contains(&KanidmClaimsValuesMap {
523 group: "group2".to_string(),
524 values: vec!["value2".to_string()],
525 }));
526
527 let grouped_claim2 = grouped_claims.iter().find(|c| c.name == "claim2").unwrap();
528 assert_eq!(grouped_claim2.values_map.len(), 1);
529 assert!(grouped_claim2.values_map.contains(&KanidmClaimsValuesMap {
530 group: "group3".to_string(),
531 values: vec!["value3".to_string()],
532 }));
533 }
534
535 #[test]
536 fn test_kanidm_claim_map_from() {
537 let mut claim_map = KanidmClaimMap {
538 name: "claim_name".to_string(),
539 join_strategy: KanidmClaimMapJoinStrategy::Array,
540 values_map: BTreeSet::from([KanidmClaimsValuesMap {
541 group: "group_name".to_string(),
542 values: vec!["boo".to_string(), "foo".to_string()],
544 }]),
545 };
546
547 assert_eq!(
548 KanidmClaimMap::from(r#"claim_name:group_name@test.example.com:;:"foo,boo""#)
549 .unwrap()
550 .normalize(),
551 claim_map,
552 );
553 assert_eq!(
554 KanidmClaimMap::from(r#"claim_name:group_name:;:"foo,boo""#)
555 .unwrap()
556 .normalize(),
557 claim_map,
558 );
559
560 claim_map.join_strategy = KanidmClaimMapJoinStrategy::Csv;
561 assert_eq!(
562 KanidmClaimMap::from(r#"claim_name:group_name:,:"foo,boo""#)
563 .unwrap()
564 .normalize(),
565 claim_map,
566 );
567
568 claim_map.join_strategy = KanidmClaimMapJoinStrategy::Ssv;
569 assert_eq!(
570 KanidmClaimMap::from(r#"claim_name:group_name: :"foo,boo""#)
571 .unwrap()
572 .normalize(),
573 claim_map,
574 );
575 }
576}