1use kaniop_k8s_util::types::normalize_spn;
2use kaniop_operator::controller::kanidm::KanidmResource;
3use kaniop_operator::crd::KanidmRef;
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 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"}]))]
70 #[serde(default)]
71 pub public: bool,
72
73 #[serde(skip_serializing_if = "Option::is_none")]
76 pub scope_map: Option<BTreeSet<KanidmScopeMap>>,
77
78 #[serde(skip_serializing_if = "Option::is_none")]
85 pub sup_scope_map: Option<BTreeSet<KanidmScopeMap>>,
86
87 #[serde(skip_serializing_if = "Option::is_none")]
89 pub claim_map: Option<BTreeSet<KanidmClaimMap>>,
90
91 #[serde(skip_serializing_if = "Option::is_none")]
96 pub strict_redirect_url: Option<bool>,
97
98 #[serde(skip_serializing_if = "Option::is_none")]
102 pub prefer_short_username: Option<bool>,
103
104 #[serde(skip_serializing_if = "Option::is_none")]
109 pub allow_localhost_redirect: Option<bool>,
110
111 #[serde(skip_serializing_if = "Option::is_none")]
117 pub allow_insecure_client_disable_pkce: Option<bool>,
118
119 #[serde(skip_serializing_if = "Option::is_none")]
125 pub jwt_legacy_crypto_enable: Option<bool>,
126}
127
128impl KanidmResource for KanidmOAuth2Client {
129 #[inline]
130 fn kanidm_ref_spec(&self) -> &KanidmRef {
131 &self.spec.kanidm_ref
132 }
133
134 #[inline]
135 fn get_namespace_selector(kanidm: &Kanidm) -> &Option<LabelSelector> {
136 &kanidm.spec.oauth2_client_namespace_selector
137 }
138}
139
140#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq, PartialOrd, Eq, Ord)]
150#[cfg_attr(feature = "schemars", derive(JsonSchema))]
151#[serde(rename_all = "camelCase")]
152pub struct KanidmScopeMap {
153 pub group: String,
155
156 #[allow(clippy::doc_overindented_list_items)]
175 pub scopes: Vec<String>,
176}
177
178impl KanidmScopeMap {
179 pub fn normalize(self) -> Self {
180 Self {
181 group: normalize_spn(&self.group),
182 ..self
183 }
184 }
185 pub fn from(s: &str) -> Option<Self> {
186 let parts = s.split(':').collect::<Vec<_>>();
187 if parts.len() != 2 {
188 return None;
189 }
190 let group = parts[0].to_string();
191 let proto_scopes = parts[1];
192 if proto_scopes.starts_with(" {").not() || proto_scopes.ends_with('}').not() {
193 return None;
194 }
195
196 let scopes = proto_scopes[2..proto_scopes.len() - 1]
197 .split(", ")
198 .map(|s| s.replace('"', ""))
199 .collect();
200 Some(Self { group, scopes })
201 }
202}
203
204#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq, PartialOrd, Eq, Ord)]
212#[cfg_attr(feature = "schemars", derive(JsonSchema))]
213#[serde(rename_all = "camelCase")]
214pub struct KanidmClaimMap {
215 pub name: String,
217
218 pub values_map: BTreeSet<KanidmClaimsValuesMap>,
219
220 #[serde(default)]
226 pub join_strategy: KanidmClaimMapJoinStrategy,
227}
228
229impl KanidmClaimMap {
230 pub fn normalize(self) -> Self {
231 Self {
232 values_map: self
233 .values_map
234 .iter()
235 .map(|vm| vm.clone().normalize())
236 .collect(),
237 ..self
238 }
239 }
240
241 pub fn from(s: &str) -> Option<Self> {
242 let parts = s.split(':').collect::<Vec<_>>();
243 if parts.len() != 4 {
244 return None;
245 }
246 let name = parts[0].to_string();
247 let group = parts[1].to_string();
248 let join_strategy = match parts[2] {
249 "," => KanidmClaimMapJoinStrategy::Csv,
250 " " => KanidmClaimMapJoinStrategy::Ssv,
251 ";" => KanidmClaimMapJoinStrategy::Array,
252 _ => return None,
253 };
254 let proto_values = parts[3];
255 if proto_values.starts_with('"').not() || proto_values.ends_with('"').not() {
256 return None;
257 }
258 let values = proto_values[1..proto_values.len() - 1]
259 .split(",")
260 .map(|s| s.to_string())
261 .collect();
262 Some(Self {
263 name,
264 join_strategy,
265 values_map: BTreeSet::from([KanidmClaimsValuesMap { group, values }]),
266 })
267 }
268
269 pub fn group(v: &[KanidmClaimMap]) -> BTreeSet<KanidmClaimMap> {
270 let mut map: HashMap<String, KanidmClaimMap> = HashMap::new();
271
272 for claim in v {
273 if let Some(existing) = map.get_mut(&claim.name) {
274 existing.values_map.extend(claim.values_map.clone());
275 } else {
276 map.insert(claim.name.clone(), claim.clone());
277 }
278 }
279
280 map.into_values().collect()
281 }
282}
283
284#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq, PartialOrd, Eq, Ord)]
285#[cfg_attr(feature = "schemars", derive(JsonSchema))]
286#[serde(rename_all = "camelCase")]
287pub struct KanidmClaimsValuesMap {
288 pub group: String,
290
291 pub values: Vec<String>,
293}
294
295impl KanidmClaimsValuesMap {
296 pub fn normalize(self) -> Self {
297 Self {
298 group: normalize_spn(&self.group),
299 ..self
300 }
301 }
302}
303
304#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq, PartialOrd, Eq, Ord)]
305#[cfg_attr(feature = "schemars", derive(JsonSchema))]
306#[serde(rename_all = "snake_case")]
307pub enum KanidmClaimMapJoinStrategy {
308 Csv,
310 Ssv,
312 #[default]
314 Array,
315}
316
317impl KanidmClaimMapJoinStrategy {
318 pub fn to_oauth2_claim_map_join(&self) -> Oauth2ClaimMapJoin {
319 match self {
320 KanidmClaimMapJoinStrategy::Csv => Oauth2ClaimMapJoin::Csv,
321 KanidmClaimMapJoinStrategy::Ssv => Oauth2ClaimMapJoin::Ssv,
322 KanidmClaimMapJoinStrategy::Array => Oauth2ClaimMapJoin::Array,
323 }
324 }
325}
326
327#[derive(Serialize, Deserialize, Clone, Debug, Default)]
331#[cfg_attr(feature = "schemars", derive(JsonSchema))]
332#[serde(rename_all = "camelCase")]
333pub struct KanidmOAuth2ClientStatus {
334 #[serde(skip_serializing_if = "Option::is_none")]
335 pub conditions: Option<Vec<Condition>>,
336
337 #[serde(skip_serializing_if = "Option::is_none")]
338 pub origin: Option<Vec<String>>,
339
340 #[serde(skip_serializing_if = "Option::is_none")]
341 pub scope_map: Option<Vec<String>>,
342
343 #[serde(skip_serializing_if = "Option::is_none")]
344 pub sup_scope_map: Option<Vec<String>>,
345
346 #[serde(skip_serializing_if = "Option::is_none")]
347 pub claims_map: Option<Vec<String>>,
348
349 pub ready: bool,
350
351 #[serde(skip_serializing_if = "Option::is_none")]
352 pub secret_name: Option<String>,
353
354 pub kanidm_ref: String,
355}
356
357#[cfg(test)]
358mod tests {
359 use super::{
360 KanidmClaimMap, KanidmClaimMapJoinStrategy, KanidmClaimsValuesMap, KanidmScopeMap,
361 };
362
363 use std::collections::BTreeSet;
364
365 #[test]
366 fn test_kanidm_scope_map_from() {
367 let scope_map = KanidmScopeMap {
368 group: "test_group".to_string(),
369 scopes: vec!["scope1".to_string(), "scope2".to_string()],
370 };
371
372 assert_eq!(
373 KanidmScopeMap::from(r#"test_group@test.example.com: {"scope1", "scope2"}"#)
374 .unwrap()
375 .normalize(),
376 scope_map,
377 );
378
379 assert_eq!(
380 KanidmScopeMap::from(r#"test_group: {"scope1", "scope2"}"#)
381 .unwrap()
382 .normalize(),
383 scope_map,
384 );
385
386 assert!(KanidmScopeMap::from(r#"test_group:{"scope1", "scope2"}"#).is_none(),);
387 assert_eq!(
388 KanidmScopeMap::from(r#"test_group: {"scope1"}"#)
389 .unwrap()
390 .normalize(),
391 KanidmScopeMap {
392 group: "test_group".to_string(),
393 scopes: vec!["scope1".to_string()],
394 }
395 );
396 }
397
398 #[test]
399 fn test_group_kanidm_claims_map() {
400 let claim1 = KanidmClaimMap {
401 name: "claim1".to_string(),
402 values_map: BTreeSet::from([KanidmClaimsValuesMap {
403 group: "group1".to_string(),
404 values: vec!["value1".to_string()],
405 }]),
406 join_strategy: KanidmClaimMapJoinStrategy::Array,
407 };
408
409 let claim2 = KanidmClaimMap {
410 name: "claim1".to_string(),
411 values_map: BTreeSet::from([KanidmClaimsValuesMap {
412 group: "group2".to_string(),
413 values: vec!["value2".to_string()],
414 }]),
415 join_strategy: KanidmClaimMapJoinStrategy::Array,
416 };
417
418 let claim3 = KanidmClaimMap {
419 name: "claim2".to_string(),
420 values_map: BTreeSet::from([KanidmClaimsValuesMap {
421 group: "group3".to_string(),
422 values: vec!["value3".to_string()],
423 }]),
424 join_strategy: KanidmClaimMapJoinStrategy::Array,
425 };
426
427 let claims = vec![claim1.clone(), claim2.clone(), claim3.clone()];
428
429 let grouped_claims = KanidmClaimMap::group(&claims);
430
431 assert_eq!(grouped_claims.len(), 2);
432
433 let grouped_claim1 = grouped_claims.iter().find(|c| c.name == "claim1").unwrap();
434 assert_eq!(grouped_claim1.values_map.len(), 2);
435 assert!(grouped_claim1.values_map.contains(&KanidmClaimsValuesMap {
436 group: "group1".to_string(),
437 values: vec!["value1".to_string()],
438 }));
439 assert!(grouped_claim1.values_map.contains(&KanidmClaimsValuesMap {
440 group: "group2".to_string(),
441 values: vec!["value2".to_string()],
442 }));
443
444 let grouped_claim2 = grouped_claims.iter().find(|c| c.name == "claim2").unwrap();
445 assert_eq!(grouped_claim2.values_map.len(), 1);
446 assert!(grouped_claim2.values_map.contains(&KanidmClaimsValuesMap {
447 group: "group3".to_string(),
448 values: vec!["value3".to_string()],
449 }));
450 }
451
452 #[test]
453 fn test_kanidm_claim_map_from() {
454 let mut claim_map = KanidmClaimMap {
455 name: "claim_name".to_string(),
456 join_strategy: KanidmClaimMapJoinStrategy::Array,
457 values_map: BTreeSet::from([KanidmClaimsValuesMap {
458 group: "group_name".to_string(),
459 values: vec!["foo".to_string(), "boo".to_string()],
460 }]),
461 };
462
463 assert_eq!(
464 KanidmClaimMap::from(r#"claim_name:group_name@test.example.com:;:"foo,boo""#)
465 .unwrap()
466 .normalize(),
467 claim_map,
468 );
469 assert_eq!(
470 KanidmClaimMap::from(r#"claim_name:group_name:;:"foo,boo""#)
471 .unwrap()
472 .normalize(),
473 claim_map,
474 );
475
476 claim_map.join_strategy = KanidmClaimMapJoinStrategy::Csv;
477 assert_eq!(
478 KanidmClaimMap::from(r#"claim_name:group_name:,:"foo,boo""#)
479 .unwrap()
480 .normalize(),
481 claim_map,
482 );
483
484 claim_map.join_strategy = KanidmClaimMapJoinStrategy::Ssv;
485 assert_eq!(
486 KanidmClaimMap::from(r#"claim_name:group_name: :"foo,boo""#)
487 .unwrap()
488 .normalize(),
489 claim_map,
490 );
491 }
492}