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