1use kaniop_k8s_util::types::normalize_spn;
2use kaniop_operator::controller::kanidm::KanidmResource;
3use kaniop_operator::crd::KanidmRef;
4
5use std::{
6 collections::{BTreeSet, HashMap},
7 ops::Not,
8};
9
10use kanidm_proto::internal::Oauth2ClaimMapJoin;
11
12use k8s_openapi::apimachinery::pkg::apis::meta::v1::Condition;
13use kube::{CustomResource, ResourceExt};
14#[cfg(feature = "schemars")]
15use schemars::JsonSchema;
16use serde::{Deserialize, Serialize};
17
18#[derive(CustomResource, Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
25#[cfg_attr(feature = "schemars", derive(JsonSchema))]
26#[kube(
27 category = "kaniop",
28 group = "kaniop.rs",
29 version = "v1beta1",
30 kind = "KanidmOAuth2Client",
31 plural = "kanidmoauth2clients",
32 singular = "kanidmoauth2client",
33 shortname = "oauth2",
34 namespaced,
35 status = "KanidmOAuth2ClientStatus",
36 doc = r#"The Kanidm OAuth2 client custom resource definition (CRD) defines an OAuth2 client
37 integration in Kanidm.
38 This resource has to be in the same namespace as the Kanidm cluster."#,
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 derive = "Default"
44)]
45#[serde(rename_all = "camelCase")]
46pub struct KanidmOAuth2ClientSpec {
47 pub kanidm_ref: KanidmRef,
48
49 pub displayname: String,
51
52 pub origin: String,
55
56 pub redirect_url: Vec<String>,
58
59 #[schemars(extend("x-kubernetes-validations" = [{"message": "Public cannot be changed.", "rule": "self == oldSelf"}]))]
67 #[serde(default)]
68 pub public: bool,
69
70 #[serde(skip_serializing_if = "Option::is_none")]
73 pub scope_map: Option<BTreeSet<KanidmScopeMap>>,
74
75 #[serde(skip_serializing_if = "Option::is_none")]
82 pub sup_scope_map: Option<BTreeSet<KanidmScopeMap>>,
83
84 #[serde(skip_serializing_if = "Option::is_none")]
86 pub claim_map: Option<BTreeSet<KanidmClaimMap>>,
87
88 #[serde(skip_serializing_if = "Option::is_none")]
93 pub strict_redirect_url: Option<bool>,
94
95 #[serde(skip_serializing_if = "Option::is_none")]
99 pub prefer_short_username: Option<bool>,
100
101 #[serde(skip_serializing_if = "Option::is_none")]
106 pub allow_localhost_redirect: Option<bool>,
107
108 #[serde(skip_serializing_if = "Option::is_none")]
114 pub allow_insecure_client_disable_pkce: Option<bool>,
115
116 #[serde(skip_serializing_if = "Option::is_none")]
122 pub jwt_legacy_crypto_enable: Option<bool>,
123}
124
125impl KanidmResource for KanidmOAuth2Client {
126 #[inline]
127 fn kanidm_name(&self) -> String {
128 self.spec.kanidm_ref.name.clone()
129 }
130
131 #[inline]
132 fn kanidm_namespace(&self) -> String {
133 self.spec
134 .kanidm_ref
135 .namespace
136 .clone()
137 .unwrap_or_else(|| self.namespace().unwrap())
139 }
140}
141
142#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq, PartialOrd, Eq, Ord)]
152#[cfg_attr(feature = "schemars", derive(JsonSchema))]
153#[serde(rename_all = "camelCase")]
154pub struct KanidmScopeMap {
155 pub group: String,
157
158 #[allow(clippy::doc_overindented_list_items)]
177 pub scopes: Vec<String>,
178}
179
180impl KanidmScopeMap {
181 pub fn normalize(self) -> Self {
182 Self {
183 group: normalize_spn(&self.group),
184 ..self
185 }
186 }
187 pub fn from(s: &str) -> Option<Self> {
188 let parts = s.split(':').collect::<Vec<_>>();
189 if parts.len() != 2 {
190 return None;
191 }
192 let group = parts[0].to_string();
193 let proto_scopes = parts[1];
194 if proto_scopes.starts_with(" {").not() || proto_scopes.ends_with('}').not() {
195 return None;
196 }
197
198 let scopes = proto_scopes[2..proto_scopes.len() - 1]
199 .split(", ")
200 .map(|s| s.replace('"', ""))
201 .collect();
202 Some(Self { group, scopes })
203 }
204}
205
206#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq, PartialOrd, Eq, Ord)]
214#[cfg_attr(feature = "schemars", derive(JsonSchema))]
215#[serde(rename_all = "camelCase")]
216pub struct KanidmClaimMap {
217 pub name: String,
219
220 pub values_map: BTreeSet<KanidmClaimsValuesMap>,
221
222 #[serde(default)]
228 pub join_strategy: KanidmClaimMapJoinStrategy,
229}
230
231impl KanidmClaimMap {
232 pub fn normalize(self) -> Self {
233 Self {
234 values_map: self
235 .values_map
236 .iter()
237 .map(|vm| vm.clone().normalize())
238 .collect(),
239 ..self
240 }
241 }
242
243 pub fn from(s: &str) -> Option<Self> {
244 let parts = s.split(':').collect::<Vec<_>>();
245 if parts.len() != 4 {
246 return None;
247 }
248 let name = parts[0].to_string();
249 let group = parts[1].to_string();
250 let join_strategy = match parts[2] {
251 "," => KanidmClaimMapJoinStrategy::Csv,
252 " " => KanidmClaimMapJoinStrategy::Ssv,
253 ";" => KanidmClaimMapJoinStrategy::Array,
254 _ => return None,
255 };
256 let proto_values = parts[3];
257 if proto_values.starts_with('"').not() || proto_values.ends_with('"').not() {
258 return None;
259 }
260 let values = proto_values[1..proto_values.len() - 1]
261 .split(",")
262 .map(|s| s.to_string())
263 .collect();
264 Some(Self {
265 name,
266 join_strategy,
267 values_map: BTreeSet::from([KanidmClaimsValuesMap { group, values }]),
268 })
269 }
270
271 pub fn group(v: &[KanidmClaimMap]) -> BTreeSet<KanidmClaimMap> {
272 let mut map: HashMap<String, KanidmClaimMap> = HashMap::new();
273
274 for claim in v {
275 if let Some(existing) = map.get_mut(&claim.name) {
276 existing.values_map.extend(claim.values_map.clone());
277 } else {
278 map.insert(claim.name.clone(), claim.clone());
279 }
280 }
281
282 map.into_values().collect()
283 }
284}
285
286#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq, PartialOrd, Eq, Ord)]
287#[cfg_attr(feature = "schemars", derive(JsonSchema))]
288#[serde(rename_all = "camelCase")]
289pub struct KanidmClaimsValuesMap {
290 pub group: String,
292
293 pub values: Vec<String>,
295}
296
297impl KanidmClaimsValuesMap {
298 pub fn normalize(self) -> Self {
299 Self {
300 group: normalize_spn(&self.group),
301 ..self
302 }
303 }
304}
305
306#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq, PartialOrd, Eq, Ord)]
307#[cfg_attr(feature = "schemars", derive(JsonSchema))]
308#[serde(rename_all = "snake_case")]
309pub enum KanidmClaimMapJoinStrategy {
310 Csv,
312 Ssv,
314 #[default]
316 Array,
317}
318
319impl KanidmClaimMapJoinStrategy {
320 pub fn to_oauth2_claim_map_join(&self) -> Oauth2ClaimMapJoin {
321 match self {
322 KanidmClaimMapJoinStrategy::Csv => Oauth2ClaimMapJoin::Csv,
323 KanidmClaimMapJoinStrategy::Ssv => Oauth2ClaimMapJoin::Ssv,
324 KanidmClaimMapJoinStrategy::Array => Oauth2ClaimMapJoin::Array,
325 }
326 }
327}
328
329#[derive(Serialize, Deserialize, Clone, Debug, Default)]
333#[cfg_attr(feature = "schemars", derive(JsonSchema))]
334#[serde(rename_all = "camelCase")]
335pub struct KanidmOAuth2ClientStatus {
336 #[serde(skip_serializing_if = "Option::is_none")]
337 pub conditions: Option<Vec<Condition>>,
338
339 #[serde(skip_serializing_if = "Option::is_none")]
340 pub origin: Option<Vec<String>>,
341
342 #[serde(skip_serializing_if = "Option::is_none")]
343 pub scope_map: Option<Vec<String>>,
344
345 #[serde(skip_serializing_if = "Option::is_none")]
346 pub sup_scope_map: Option<Vec<String>>,
347
348 #[serde(skip_serializing_if = "Option::is_none")]
349 pub claims_map: Option<Vec<String>>,
350
351 pub ready: bool,
352
353 #[serde(skip_serializing_if = "Option::is_none")]
354 pub secret_name: Option<String>,
355
356 pub kanidm_ref: String,
357}
358
359#[cfg(test)]
360mod tests {
361 use super::{
362 KanidmClaimMap, KanidmClaimMapJoinStrategy, KanidmClaimsValuesMap, KanidmScopeMap,
363 };
364
365 use std::collections::BTreeSet;
366
367 #[test]
368 fn test_kanidm_scope_map_from() {
369 let scope_map = KanidmScopeMap {
370 group: "test_group".to_string(),
371 scopes: vec!["scope1".to_string(), "scope2".to_string()],
372 };
373
374 assert_eq!(
375 KanidmScopeMap::from(r#"test_group@test.example.com: {"scope1", "scope2"}"#)
376 .unwrap()
377 .normalize(),
378 scope_map,
379 );
380
381 assert_eq!(
382 KanidmScopeMap::from(r#"test_group: {"scope1", "scope2"}"#)
383 .unwrap()
384 .normalize(),
385 scope_map,
386 );
387
388 assert!(KanidmScopeMap::from(r#"test_group:{"scope1", "scope2"}"#).is_none(),);
389 assert_eq!(
390 KanidmScopeMap::from(r#"test_group: {"scope1"}"#)
391 .unwrap()
392 .normalize(),
393 KanidmScopeMap {
394 group: "test_group".to_string(),
395 scopes: vec!["scope1".to_string()],
396 }
397 );
398 }
399
400 #[test]
401 fn test_group_kanidm_claims_map() {
402 let claim1 = KanidmClaimMap {
403 name: "claim1".to_string(),
404 values_map: BTreeSet::from([KanidmClaimsValuesMap {
405 group: "group1".to_string(),
406 values: vec!["value1".to_string()],
407 }]),
408 join_strategy: KanidmClaimMapJoinStrategy::Array,
409 };
410
411 let claim2 = KanidmClaimMap {
412 name: "claim1".to_string(),
413 values_map: BTreeSet::from([KanidmClaimsValuesMap {
414 group: "group2".to_string(),
415 values: vec!["value2".to_string()],
416 }]),
417 join_strategy: KanidmClaimMapJoinStrategy::Array,
418 };
419
420 let claim3 = KanidmClaimMap {
421 name: "claim2".to_string(),
422 values_map: BTreeSet::from([KanidmClaimsValuesMap {
423 group: "group3".to_string(),
424 values: vec!["value3".to_string()],
425 }]),
426 join_strategy: KanidmClaimMapJoinStrategy::Array,
427 };
428
429 let claims = vec![claim1.clone(), claim2.clone(), claim3.clone()];
430
431 let grouped_claims = KanidmClaimMap::group(&claims);
432
433 assert_eq!(grouped_claims.len(), 2);
434
435 let grouped_claim1 = grouped_claims.iter().find(|c| c.name == "claim1").unwrap();
436 assert_eq!(grouped_claim1.values_map.len(), 2);
437 assert!(grouped_claim1.values_map.contains(&KanidmClaimsValuesMap {
438 group: "group1".to_string(),
439 values: vec!["value1".to_string()],
440 }));
441 assert!(grouped_claim1.values_map.contains(&KanidmClaimsValuesMap {
442 group: "group2".to_string(),
443 values: vec!["value2".to_string()],
444 }));
445
446 let grouped_claim2 = grouped_claims.iter().find(|c| c.name == "claim2").unwrap();
447 assert_eq!(grouped_claim2.values_map.len(), 1);
448 assert!(grouped_claim2.values_map.contains(&KanidmClaimsValuesMap {
449 group: "group3".to_string(),
450 values: vec!["value3".to_string()],
451 }));
452 }
453
454 #[test]
455 fn test_kanidm_claim_map_from() {
456 let mut claim_map = KanidmClaimMap {
457 name: "claim_name".to_string(),
458 join_strategy: KanidmClaimMapJoinStrategy::Array,
459 values_map: BTreeSet::from([KanidmClaimsValuesMap {
460 group: "group_name".to_string(),
461 values: vec!["foo".to_string(), "boo".to_string()],
462 }]),
463 };
464
465 assert_eq!(
466 KanidmClaimMap::from(r#"claim_name:group_name@test.example.com:;:"foo,boo""#)
467 .unwrap()
468 .normalize(),
469 claim_map,
470 );
471 assert_eq!(
472 KanidmClaimMap::from(r#"claim_name:group_name:;:"foo,boo""#)
473 .unwrap()
474 .normalize(),
475 claim_map,
476 );
477
478 claim_map.join_strategy = KanidmClaimMapJoinStrategy::Csv;
479 assert_eq!(
480 KanidmClaimMap::from(r#"claim_name:group_name:,:"foo,boo""#)
481 .unwrap()
482 .normalize(),
483 claim_map,
484 );
485
486 claim_map.join_strategy = KanidmClaimMapJoinStrategy::Ssv;
487 assert_eq!(
488 KanidmClaimMap::from(r#"claim_name:group_name: :"foo,boo""#)
489 .unwrap()
490 .normalize(),
491 claim_map,
492 );
493 }
494}