use kaniop_k8s_util::types::normalize_spn;
use kaniop_operator::controller::kanidm::KanidmResource;
use kaniop_operator::crd::{KanidmRef, SecretRotation, MetadataTemplate};
use kaniop_operator::kanidm::crd::Kanidm;
use std::{
collections::{BTreeSet, HashMap},
ops::Not,
};
use kanidm_proto::internal::Oauth2ClaimMapJoin;
use k8s_openapi::apimachinery::pkg::apis::meta::v1::{Condition, LabelSelector};
use kube::CustomResource;
#[cfg(feature = "schemars")]
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
#[derive(CustomResource, Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "schemars", derive(JsonSchema))]
#[kube(
category = "kaniop",
group = "kaniop.rs",
version = "v1beta1",
kind = "KanidmOAuth2Client",
plural = "kanidmoauth2clients",
singular = "kanidmoauth2client",
shortname = "oauth2",
namespaced,
status = "KanidmOAuth2ClientStatus",
doc = r#"The Kanidm OAuth2 client custom resource definition (CRD) defines an OAuth2 client
integration in Kanidm."#,
printcolumn = r#"{"name":"Kanidm","type":"string","jsonPath":".status.kanidmRef"}"#,
printcolumn = r#"{"name":"Public","type":"string","jsonPath":".spec.public"}"#,
printcolumn = r#"{"name":"Secret","type":"string","jsonPath":".status.secretName"}"#,
printcolumn = r#"{"name":"Ready","type":"boolean","jsonPath":".status.ready"}"#,
printcolumn = r#"{"name":"Age","type":"date","jsonPath":".metadata.creationTimestamp"}"#,
derive = "Default"
)]
#[serde(rename_all = "camelCase")]
pub struct KanidmOAuth2ClientSpec {
pub kanidm_ref: KanidmRef,
#[schemars(extend("x-kubernetes-validations" = [{"message": "kanidmName cannot be changed.", "rule": "self == oldSelf"}]))]
#[serde(skip_serializing_if = "Option::is_none")]
pub kanidm_name: Option<String>,
pub displayname: String,
pub origin: String,
pub redirect_url: Vec<String>,
#[schemars(extend("x-kubernetes-validations" = [{"message": "Public cannot be changed.", "rule": "self == oldSelf"}]))]
#[serde(default)]
pub public: bool,
#[serde(skip_serializing_if = "Option::is_none")]
pub scope_map: Option<BTreeSet<KanidmScopeMap>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub sup_scope_map: Option<BTreeSet<KanidmScopeMap>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub claim_map: Option<BTreeSet<KanidmClaimMap>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub strict_redirect_url: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub prefer_short_username: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub allow_localhost_redirect: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub allow_insecure_client_disable_pkce: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub jwt_legacy_crypto_enable: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub disable_consent_prompt: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub secret_rotation: Option<SecretRotation>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub secret_template: Option<MetadataTemplate>,
#[serde(skip_serializing_if = "Option::is_none")]
pub image: Option<OAuth2ClientImageSpec>,
}
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "schemars", derive(JsonSchema))]
#[serde(rename_all = "camelCase")]
pub struct OAuth2ClientImageSpec {
pub url: String,
}
impl KanidmResource for KanidmOAuth2Client {
#[inline]
fn kanidm_ref_spec(&self) -> &KanidmRef {
&self.spec.kanidm_ref
}
#[inline]
fn get_namespace_selector(kanidm: &Kanidm) -> &Option<LabelSelector> {
&kanidm.spec.oauth2_client_namespace_selector
}
#[inline]
fn kanidm_name_override(&self) -> Option<&str> {
self.spec.kanidm_name.as_deref()
}
}
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq, PartialOrd, Eq, Ord)]
#[cfg_attr(feature = "schemars", derive(JsonSchema))]
#[serde(rename_all = "camelCase")]
pub struct KanidmScopeMap {
pub group: String,
#[allow(clippy::doc_overindented_list_items)]
pub scopes: Vec<String>,
}
impl KanidmScopeMap {
pub fn normalize(self) -> Self {
let mut scopes = self.scopes;
scopes.sort();
Self {
group: normalize_spn(&self.group),
scopes,
}
}
pub fn from(s: &str) -> Option<Self> {
let parts = s.split(':').collect::<Vec<_>>();
if parts.len() != 2 {
return None;
}
let group = parts[0].to_string();
let proto_scopes = parts[1];
if proto_scopes.starts_with(" {").not() || proto_scopes.ends_with('}').not() {
return None;
}
let scopes = proto_scopes[2..proto_scopes.len() - 1]
.split(", ")
.map(|s| s.replace('"', ""))
.collect();
Some(Self { group, scopes })
}
}
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq, PartialOrd, Eq, Ord)]
#[cfg_attr(feature = "schemars", derive(JsonSchema))]
#[serde(rename_all = "camelCase")]
pub struct KanidmClaimMap {
pub name: String,
pub values_map: BTreeSet<KanidmClaimsValuesMap>,
#[serde(default)]
pub join_strategy: KanidmClaimMapJoinStrategy,
}
impl KanidmClaimMap {
pub fn normalize(self) -> Self {
Self {
values_map: self
.values_map
.iter()
.map(|vm| vm.clone().normalize())
.collect(),
..self
}
}
pub fn from(s: &str) -> Option<Self> {
let parts = s.split(':').collect::<Vec<_>>();
if parts.len() != 4 {
return None;
}
let name = parts[0].to_string();
let group = parts[1].to_string();
let join_strategy = match parts[2] {
"," => KanidmClaimMapJoinStrategy::Csv,
" " => KanidmClaimMapJoinStrategy::Ssv,
";" => KanidmClaimMapJoinStrategy::Array,
_ => return None,
};
let proto_values = parts[3];
if proto_values.starts_with('"').not() || proto_values.ends_with('"').not() {
return None;
}
let values = proto_values[1..proto_values.len() - 1]
.split(",")
.map(|s| s.to_string())
.collect();
Some(Self {
name,
join_strategy,
values_map: BTreeSet::from([KanidmClaimsValuesMap { group, values }]),
})
}
pub fn group(v: &[KanidmClaimMap]) -> BTreeSet<KanidmClaimMap> {
let mut map: HashMap<String, KanidmClaimMap> = HashMap::new();
for claim in v {
if let Some(existing) = map.get_mut(&claim.name) {
existing.values_map.extend(claim.values_map.clone());
} else {
map.insert(claim.name.clone(), claim.clone());
}
}
map.into_values().collect()
}
}
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq, PartialOrd, Eq, Ord)]
#[cfg_attr(feature = "schemars", derive(JsonSchema))]
#[serde(rename_all = "camelCase")]
pub struct KanidmClaimsValuesMap {
pub group: String,
pub values: Vec<String>,
}
impl KanidmClaimsValuesMap {
pub fn normalize(self) -> Self {
let mut values = self.values;
values.sort();
Self {
group: normalize_spn(&self.group),
values,
}
}
}
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq, PartialOrd, Eq, Ord)]
#[cfg_attr(feature = "schemars", derive(JsonSchema))]
#[serde(rename_all = "snake_case")]
pub enum KanidmClaimMapJoinStrategy {
Csv,
Ssv,
#[default]
Array,
}
impl KanidmClaimMapJoinStrategy {
pub fn to_oauth2_claim_map_join(&self) -> Oauth2ClaimMapJoin {
match self {
KanidmClaimMapJoinStrategy::Csv => Oauth2ClaimMapJoin::Csv,
KanidmClaimMapJoinStrategy::Ssv => Oauth2ClaimMapJoin::Ssv,
KanidmClaimMapJoinStrategy::Array => Oauth2ClaimMapJoin::Array,
}
}
}
#[derive(Serialize, Deserialize, Clone, Debug, Default)]
#[cfg_attr(feature = "schemars", derive(JsonSchema))]
#[serde(rename_all = "camelCase")]
pub struct KanidmOAuth2ClientStatus {
#[serde(skip_serializing_if = "Option::is_none")]
pub conditions: Option<Vec<Condition>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub origin: Option<Vec<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub scope_map: Option<Vec<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub sup_scope_map: Option<Vec<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub claims_map: Option<Vec<String>>,
pub ready: bool,
#[serde(skip_serializing_if = "Option::is_none")]
pub secret_name: Option<String>,
pub kanidm_ref: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub image: Option<OAuth2ClientImageStatus>,
}
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq)]
#[cfg_attr(feature = "schemars", derive(JsonSchema))]
#[serde(rename_all = "camelCase")]
pub struct OAuth2ClientImageStatus {
pub url: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub etag: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub last_modified: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub content_length: Option<u64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub content_hash: Option<String>,
}
#[cfg(test)]
mod tests {
use super::{
KanidmClaimMap, KanidmClaimMapJoinStrategy, KanidmClaimsValuesMap, KanidmScopeMap,
};
use std::collections::BTreeSet;
#[test]
fn test_kanidm_scope_map_from() {
let scope_map = KanidmScopeMap {
group: "test_group".to_string(),
scopes: vec!["scope1".to_string(), "scope2".to_string()],
};
assert_eq!(
KanidmScopeMap::from(r#"test_group@test.example.com: {"scope1", "scope2"}"#)
.unwrap()
.normalize(),
scope_map,
);
assert_eq!(
KanidmScopeMap::from(r#"test_group: {"scope1", "scope2"}"#)
.unwrap()
.normalize(),
scope_map,
);
assert!(KanidmScopeMap::from(r#"test_group:{"scope1", "scope2"}"#).is_none(),);
assert_eq!(
KanidmScopeMap::from(r#"test_group: {"scope1"}"#)
.unwrap()
.normalize(),
KanidmScopeMap {
group: "test_group".to_string(),
scopes: vec!["scope1".to_string()],
}
);
}
#[test]
fn test_group_kanidm_claims_map() {
let claim1 = KanidmClaimMap {
name: "claim1".to_string(),
values_map: BTreeSet::from([KanidmClaimsValuesMap {
group: "group1".to_string(),
values: vec!["value1".to_string()],
}]),
join_strategy: KanidmClaimMapJoinStrategy::Array,
};
let claim2 = KanidmClaimMap {
name: "claim1".to_string(),
values_map: BTreeSet::from([KanidmClaimsValuesMap {
group: "group2".to_string(),
values: vec!["value2".to_string()],
}]),
join_strategy: KanidmClaimMapJoinStrategy::Array,
};
let claim3 = KanidmClaimMap {
name: "claim2".to_string(),
values_map: BTreeSet::from([KanidmClaimsValuesMap {
group: "group3".to_string(),
values: vec!["value3".to_string()],
}]),
join_strategy: KanidmClaimMapJoinStrategy::Array,
};
let claims = vec![claim1.clone(), claim2.clone(), claim3.clone()];
let grouped_claims = KanidmClaimMap::group(&claims);
assert_eq!(grouped_claims.len(), 2);
let grouped_claim1 = grouped_claims.iter().find(|c| c.name == "claim1").unwrap();
assert_eq!(grouped_claim1.values_map.len(), 2);
assert!(grouped_claim1.values_map.contains(&KanidmClaimsValuesMap {
group: "group1".to_string(),
values: vec!["value1".to_string()],
}));
assert!(grouped_claim1.values_map.contains(&KanidmClaimsValuesMap {
group: "group2".to_string(),
values: vec!["value2".to_string()],
}));
let grouped_claim2 = grouped_claims.iter().find(|c| c.name == "claim2").unwrap();
assert_eq!(grouped_claim2.values_map.len(), 1);
assert!(grouped_claim2.values_map.contains(&KanidmClaimsValuesMap {
group: "group3".to_string(),
values: vec!["value3".to_string()],
}));
}
#[test]
fn test_kanidm_claim_map_from() {
let mut claim_map = KanidmClaimMap {
name: "claim_name".to_string(),
join_strategy: KanidmClaimMapJoinStrategy::Array,
values_map: BTreeSet::from([KanidmClaimsValuesMap {
group: "group_name".to_string(),
values: vec!["boo".to_string(), "foo".to_string()],
}]),
};
assert_eq!(
KanidmClaimMap::from(r#"claim_name:group_name@test.example.com:;:"foo,boo""#)
.unwrap()
.normalize(),
claim_map,
);
assert_eq!(
KanidmClaimMap::from(r#"claim_name:group_name:;:"foo,boo""#)
.unwrap()
.normalize(),
claim_map,
);
claim_map.join_strategy = KanidmClaimMapJoinStrategy::Csv;
assert_eq!(
KanidmClaimMap::from(r#"claim_name:group_name:,:"foo,boo""#)
.unwrap()
.normalize(),
claim_map,
);
claim_map.join_strategy = KanidmClaimMapJoinStrategy::Ssv;
assert_eq!(
KanidmClaimMap::from(r#"claim_name:group_name: :"foo,boo""#)
.unwrap()
.normalize(),
claim_map,
);
}
}