Skip to main content

kaniop_operator/kanidm/reconcile/
mail_sender.rs

1use super::super::controller::context::Context;
2use super::CLUSTER_LABEL;
3use crate::controller::{INSTANCE_LABEL, MANAGED_BY_LABEL, NAME_LABEL};
4use crate::kanidm::crd::{CaBundleRef, Kanidm, MailSenderSpec, MailSenderStatus};
5use crate::metrics::{
6    KANIDM_OP_CREATE, KANIDM_OP_DELETE, KANIDM_OP_DESTROY_API_TOKEN, KANIDM_OP_GENERATE_API_TOKEN,
7    KANIDM_OP_GET, KANIDM_OP_LIST_API_TOKENS, KANIDM_OP_REMOVE_MEMBERS, KANIDM_OP_SET_MEMBERS,
8    KANIDM_OP_UPDATE, KANIDM_OUTCOME_CHANGED, KANIDM_OUTCOME_ERROR, KANIDM_OUTCOME_UNCHANGED,
9    KANIDM_RESOURCE_MAIL_SENDER, record_kanidm_sdk_call,
10};
11use kaniop_backup_core::auth::{
12    build_ca_bundle_volume, build_ca_bundle_volume_mount, ca_bundle_path,
13};
14use kaniop_k8s_util::error::{Error, Result};
15use kaniop_k8s_util::types::normalize_spn;
16
17use std::collections::BTreeMap;
18use std::sync::Arc;
19
20use k8s_openapi::api::apps::v1::{Deployment, DeploymentSpec, DeploymentStrategy};
21use k8s_openapi::api::core::v1::{
22    ConfigMap, Container, KeyToPath, PodSecurityContext, PodSpec, PodTemplateSpec, Secret,
23    SecretVolumeSource, Volume, VolumeMount,
24};
25use kanidm_client::{ClientError, KanidmClient};
26use kanidm_proto::internal::OperationError;
27use kube::api::{Api, DeleteParams};
28use kube::{Resource, ResourceExt};
29use tracing::{debug, info};
30
31const MAIL_SENDER_LABEL: &str = "mail-sender";
32const MAIL_SENDER_COMPONENT: &str = "kanidm-mail-sender";
33const MESSAGE_SENDERS_GROUP: &str = "idm_message_senders";
34const MAIL_SENDER_SERVICE_ACCOUNT_SUFFIX: &str = "mail-sender";
35const MAIL_SENDER_TOKEN_SUFFIX: &str = "mail-sender-token";
36const MAIL_SENDER_CONFIG_SUFFIX: &str = "mail-sender-config";
37const MAIL_SENDER_DEPLOYMENT_SUFFIX: &str = "mail-sender";
38const DEFAULT_QUEUE_POLL_INTERVAL: i32 = 5;
39const DEFAULT_CONNECT_TIMEOUT: i32 = 15;
40const CLIENT_CONFIG_KEY: &str = "client.toml";
41const MAIL_CONFIG_KEY: &str = "mail-sender.toml";
42const MAIL_SENDER_CA_HASH_ANNOTATION: &str = "kaniop.rs/mail-sender-ca-hash";
43const ENTRY_MANAGED_BY: &str = "idm_admin";
44
45pub fn mail_sender_service_account_name(kanidm_name: &str) -> String {
46    format!("{kanidm_name}-{MAIL_SENDER_SERVICE_ACCOUNT_SUFFIX}")
47}
48
49pub fn mail_sender_token_secret_name(kanidm_name: &str) -> String {
50    format!("{kanidm_name}-{MAIL_SENDER_TOKEN_SUFFIX}")
51}
52
53pub fn mail_sender_config_map_name(kanidm_name: &str) -> String {
54    format!("{kanidm_name}-{MAIL_SENDER_CONFIG_SUFFIX}")
55}
56
57pub fn mail_sender_deployment_name(kanidm_name: &str) -> String {
58    format!("{kanidm_name}-{MAIL_SENDER_DEPLOYMENT_SUFFIX}")
59}
60
61pub async fn reconcile_mail_sender(
62    kanidm: &Kanidm,
63    kanidm_client: Arc<KanidmClient>,
64    ctx: Arc<Context>,
65) -> Result<(Option<MailSenderStatus>, bool)> {
66    let namespace = kanidm.namespace().unwrap();
67    let kanidm_name = kanidm.name_any();
68
69    if let Some(mail_sender_spec) = &kanidm.spec.mail_sender {
70        info!(namespace, kanidm_name, "reconciling mail sender");
71
72        let sa_name = mail_sender_service_account_name(&kanidm_name);
73        let config_secret_name = mail_sender_config_map_name(&kanidm_name);
74        let deployment_name = mail_sender_deployment_name(&kanidm_name);
75
76        let mut changed = false;
77        // Validate the user-supplied CA before mutating Kanidm accounts or tokens.
78        let ca_hash =
79            mail_sender_ca_hash(&ctx, &namespace, mail_sender_spec.ca_bundle_ref.as_ref()).await?;
80
81        let sa_changed = ensure_mail_sender_service_account(
82            &kanidm_client,
83            &sa_name,
84            &kanidm.spec.domain,
85            &ctx.kaniop_ctx.metrics,
86        )
87        .await?;
88        changed |= sa_changed;
89
90        let group_changed =
91            ensure_mail_sender_in_group(&kanidm_client, &sa_name, &ctx.kaniop_ctx.metrics).await?;
92        changed |= group_changed;
93
94        let current_token_id = kanidm
95            .status
96            .as_ref()
97            .and_then(|s| s.mail_sender.as_ref())
98            .and_then(|ms| ms.token_id.clone());
99
100        let (token, token_id, token_changed) = ensure_mail_sender_token(
101            &kanidm_client,
102            &ctx,
103            &namespace,
104            &config_secret_name,
105            &sa_name,
106            current_token_id,
107            &ctx.kaniop_ctx.metrics,
108        )
109        .await?;
110        changed |= token_changed;
111
112        let smtp_credentials = read_smtp_credentials(&ctx, mail_sender_spec, &namespace).await?;
113
114        let config_secret = create_config_secret(
115            kanidm,
116            &config_secret_name,
117            mail_sender_spec,
118            &token,
119            &smtp_credentials,
120        )?;
121        kanidm.patch(&ctx, config_secret).await?;
122
123        let deployment = create_deployment(
124            kanidm,
125            &deployment_name,
126            mail_sender_spec,
127            &config_secret_name,
128            ca_hash.as_deref(),
129        )?;
130        kanidm.patch(&ctx, deployment).await?;
131
132        let deployment_api: Api<Deployment> =
133            Api::namespaced(ctx.kaniop_ctx.client.clone(), &namespace);
134        let deployment_status = deployment_api
135            .get(&deployment_name)
136            .await
137            .map_err(|e| Error::kube_error("get", "deployment", &namespace, &deployment_name, e))?;
138
139        let ready = deployment_status
140            .status
141            .as_ref()
142            .is_some_and(|s| s.ready_replicas.unwrap_or(0) >= 1);
143
144        Ok((
145            Some(MailSenderStatus {
146                service_account_name: sa_name,
147                token_secret_name: config_secret_name.clone(),
148                deployment_name,
149                config_map_name: config_secret_name,
150                token_id: Some(token_id),
151                ready,
152            }),
153            changed,
154        ))
155    } else {
156        debug!(
157            namespace,
158            kanidm_name, "mail sender not enabled, cleaning up resources"
159        );
160        let cleanup_changed = cleanup_mail_sender_resources(kanidm, &ctx).await?;
161        Ok((None, cleanup_changed))
162    }
163}
164
165async fn ensure_mail_sender_service_account(
166    kanidm_client: &KanidmClient,
167    name: &str,
168    domain: &str,
169    metrics: &crate::metrics::ControllerMetrics,
170) -> Result<bool> {
171    debug!(name, "ensuring mail sender service account exists");
172
173    let display_name = format!("Mail Sender ({domain})");
174
175    let start = tokio::time::Instant::now();
176    let create_result = kanidm_client
177        .idm_service_account_create(name, &display_name, ENTRY_MANAGED_BY)
178        .await;
179
180    match create_result {
181        Ok(_) => {
182            metrics.record_kanidm_sdk_outcome(
183                KANIDM_RESOURCE_MAIL_SENDER,
184                KANIDM_OP_CREATE,
185                KANIDM_OUTCOME_CHANGED,
186                start.elapsed(),
187            );
188            Ok(true)
189        }
190        Err(e) if is_already_exists_error(&e) => {
191            metrics.record_kanidm_sdk_outcome(
192                KANIDM_RESOURCE_MAIL_SENDER,
193                KANIDM_OP_CREATE,
194                KANIDM_OUTCOME_UNCHANGED,
195                start.elapsed(),
196            );
197            debug!(name, "service account already exists, updating");
198            let start = tokio::time::Instant::now();
199            kanidm_client
200                .idm_service_account_update(name, None, Some(&display_name), None, None)
201                .await
202                .map_err(|e| {
203                    metrics.record_kanidm_sdk_outcome(
204                        KANIDM_RESOURCE_MAIL_SENDER,
205                        KANIDM_OP_UPDATE,
206                        KANIDM_OUTCOME_ERROR,
207                        start.elapsed(),
208                    );
209                    Error::KanidmClientError(
210                        format!("failed to update service account {name}"),
211                        Box::new(e),
212                    )
213                })?;
214            metrics.record_kanidm_sdk_outcome(
215                KANIDM_RESOURCE_MAIL_SENDER,
216                KANIDM_OP_UPDATE,
217                KANIDM_OUTCOME_UNCHANGED,
218                start.elapsed(),
219            );
220            Ok(false)
221        }
222        Err(e) => {
223            metrics.record_kanidm_sdk_outcome(
224                KANIDM_RESOURCE_MAIL_SENDER,
225                KANIDM_OP_CREATE,
226                KANIDM_OUTCOME_ERROR,
227                start.elapsed(),
228            );
229            Err(Error::KanidmClientError(
230                format!("failed to create service account {name}"),
231                Box::new(e),
232            ))
233        }
234    }
235}
236
237fn group_contains_member(members: &[String], name: &str) -> bool {
238    members
239        .iter()
240        .any(|m| normalize_spn(m) == normalize_spn(name))
241}
242
243async fn ensure_mail_sender_in_group(
244    kanidm_client: &KanidmClient,
245    name: &str,
246    metrics: &crate::metrics::ControllerMetrics,
247) -> Result<bool> {
248    debug!(name, "ensuring mail sender is in message_senders group");
249
250    let start = tokio::time::Instant::now();
251    let members_result = kanidm_client
252        .idm_group_get_members(MESSAGE_SENDERS_GROUP)
253        .await;
254
255    let current_members = match members_result {
256        Ok(Some(members)) => {
257            metrics.record_kanidm_sdk_outcome(
258                KANIDM_RESOURCE_MAIL_SENDER,
259                KANIDM_OP_GET,
260                KANIDM_OUTCOME_UNCHANGED,
261                start.elapsed(),
262            );
263            members
264        }
265        Ok(None) => {
266            metrics.record_kanidm_sdk_outcome(
267                KANIDM_RESOURCE_MAIL_SENDER,
268                KANIDM_OP_GET,
269                KANIDM_OUTCOME_UNCHANGED,
270                start.elapsed(),
271            );
272            vec![]
273        }
274        Err(e) => {
275            metrics.record_kanidm_sdk_outcome(
276                KANIDM_RESOURCE_MAIL_SENDER,
277                KANIDM_OP_GET,
278                KANIDM_OUTCOME_ERROR,
279                start.elapsed(),
280            );
281            return Err(Error::KanidmClientError(
282                format!("failed to get members of {MESSAGE_SENDERS_GROUP}"),
283                Box::new(e),
284            ));
285        }
286    };
287
288    if group_contains_member(&current_members, name) {
289        debug!(name, "service account already in group");
290        return Ok(false);
291    }
292
293    let start = tokio::time::Instant::now();
294    let add_result = kanidm_client
295        .idm_group_add_members(MESSAGE_SENDERS_GROUP, &[name])
296        .await;
297
298    match add_result {
299        Ok(_) => {
300            metrics.record_kanidm_sdk_outcome(
301                KANIDM_RESOURCE_MAIL_SENDER,
302                KANIDM_OP_SET_MEMBERS,
303                KANIDM_OUTCOME_CHANGED,
304                start.elapsed(),
305            );
306            Ok(true)
307        }
308        Err(e) => {
309            metrics.record_kanidm_sdk_outcome(
310                KANIDM_RESOURCE_MAIL_SENDER,
311                KANIDM_OP_SET_MEMBERS,
312                KANIDM_OUTCOME_ERROR,
313                start.elapsed(),
314            );
315            Err(Error::KanidmClientError(
316                format!("failed to add {name} to {MESSAGE_SENDERS_GROUP}"),
317                Box::new(e),
318            ))
319        }
320    }
321}
322
323async fn ensure_mail_sender_token(
324    kanidm_client: &KanidmClient,
325    ctx: &Context,
326    namespace: &str,
327    config_secret_name: &str,
328    name: &str,
329    current_token_id: Option<String>,
330    metrics: &crate::metrics::ControllerMetrics,
331) -> Result<(String, String, bool)> {
332    debug!(name, current_token_id = ?current_token_id, "ensuring mail sender API token exists");
333
334    let start = tokio::time::Instant::now();
335    let existing_tokens_result = kanidm_client.idm_service_account_list_api_token(name).await;
336    let existing_tokens = match existing_tokens_result {
337        Ok(tokens) => {
338            metrics.record_kanidm_sdk_outcome(
339                KANIDM_RESOURCE_MAIL_SENDER,
340                KANIDM_OP_LIST_API_TOKENS,
341                KANIDM_OUTCOME_UNCHANGED,
342                start.elapsed(),
343            );
344            tokens
345        }
346        Err(ClientError::Http(status, _, _)) if status == 404 => {
347            metrics.record_kanidm_sdk_outcome(
348                KANIDM_RESOURCE_MAIL_SENDER,
349                KANIDM_OP_LIST_API_TOKENS,
350                KANIDM_OUTCOME_UNCHANGED,
351                start.elapsed(),
352            );
353            vec![]
354        }
355        Err(e) => {
356            metrics.record_kanidm_sdk_outcome(
357                KANIDM_RESOURCE_MAIL_SENDER,
358                KANIDM_OP_LIST_API_TOKENS,
359                KANIDM_OUTCOME_ERROR,
360                start.elapsed(),
361            );
362            return Err(Error::KanidmClientError(
363                format!("failed to list API tokens for {name}"),
364                Box::new(e),
365            ));
366        }
367    };
368
369    let existing_mail_sender_tokens: Vec<_> = existing_tokens
370        .iter()
371        .filter(|t| t.label == MAIL_SENDER_COMPONENT)
372        .collect();
373
374    if let Some(token) = existing_mail_sender_tokens.first() {
375        if current_token_id.as_ref() == Some(&token.token_id.to_string()) {
376            debug!(name, token_id = %token.token_id, "mail sender token already exists with matching token_id, reading from existing secret");
377            if let Some(existing_token_value) =
378                read_token_from_config_secret(ctx, namespace, config_secret_name).await?
379            {
380                return Ok((existing_token_value, token.token_id.to_string(), false));
381            }
382            debug!(name, token_id = %token.token_id, "existing token value not found in secret, destroying all tokens and regenerating");
383        } else {
384            debug!(name, old_token_id = %token.token_id, expected_token_id = ?current_token_id, "mail sender token exists but token_id mismatch, destroying all tokens and regenerating");
385        }
386
387        for token in existing_mail_sender_tokens {
388            record_kanidm_sdk_call(
389                metrics,
390                KANIDM_RESOURCE_MAIL_SENDER,
391                KANIDM_OP_DESTROY_API_TOKEN,
392                KANIDM_OUTCOME_CHANGED,
393                kanidm_client.idm_service_account_destroy_api_token(name, token.token_id),
394            )
395            .await
396            .map_err(|e| {
397                Error::KanidmClientError(
398                    format!("failed to destroy API token {} for {name}", token.token_id),
399                    Box::new(e),
400                )
401            })?;
402        }
403    }
404
405    debug!(name, "generating new read-write API token for mail sender");
406
407    let token_value = record_kanidm_sdk_call(
408        metrics,
409        KANIDM_RESOURCE_MAIL_SENDER,
410        KANIDM_OP_GENERATE_API_TOKEN,
411        KANIDM_OUTCOME_CHANGED,
412        kanidm_client.idm_service_account_generate_api_token(
413            name,
414            MAIL_SENDER_COMPONENT,
415            None,
416            true,
417            false,
418        ),
419    )
420    .await
421    .map_err(|e| {
422        Error::KanidmClientError(
423            format!("failed to generate API token for {name}"),
424            Box::new(e),
425        )
426    })?;
427
428    let new_tokens = record_kanidm_sdk_call(
429        metrics,
430        KANIDM_RESOURCE_MAIL_SENDER,
431        KANIDM_OP_LIST_API_TOKENS,
432        KANIDM_OUTCOME_UNCHANGED,
433        kanidm_client.idm_service_account_list_api_token(name),
434    )
435    .await
436    .map_err(|e| {
437        Error::KanidmClientError(
438            format!("failed to list API tokens for {name} after generation"),
439            Box::new(e),
440        )
441    })?;
442
443    let new_token = new_tokens
444        .iter()
445        .find(|t| t.label == MAIL_SENDER_COMPONENT)
446        .ok_or_else(|| {
447            Error::MissingData(format!(
448                "generated token with label {MAIL_SENDER_COMPONENT} not found for {name}"
449            ))
450        })?;
451
452    Ok((token_value, new_token.token_id.to_string(), true))
453}
454
455async fn read_token_from_config_secret(
456    ctx: &Context,
457    namespace: &str,
458    name: &str,
459) -> Result<Option<String>> {
460    let secret_api: Api<Secret> = Api::namespaced(ctx.kaniop_ctx.client.clone(), namespace);
461    let secret = match secret_api.get(name).await {
462        Ok(s) => s,
463        Err(kube::Error::Api(e)) if e.code == 404 => {
464            debug!(
465                name,
466                "mail sender config secret not found, will regenerate token"
467            );
468            return Ok(None);
469        }
470        Err(e) => {
471            return Err(Error::kube_error(
472                "get",
473                "mail sender config secret",
474                namespace,
475                name,
476                e,
477            ));
478        }
479    };
480
481    let mail_config = secret
482        .string_data
483        .as_ref()
484        .and_then(|d| d.get(MAIL_CONFIG_KEY).cloned())
485        .or_else(|| {
486            secret
487                .data
488                .as_ref()
489                .and_then(|d| d.get(MAIL_CONFIG_KEY))
490                .map(|v| String::from_utf8_lossy(&v.0).to_string())
491        });
492
493    match mail_config {
494        Some(config) => {
495            let token = config
496                .lines()
497                .find(|line| line.starts_with("token = "))
498                .and_then(|line| line.strip_prefix("token = "))
499                .and_then(|value| value.strip_prefix('"').and_then(|v| v.strip_suffix('"')))
500                .map(|s| s.to_string());
501            Ok(token)
502        }
503        None => {
504            debug!(
505                name,
506                "mail sender config secret missing mail-sender.toml key, will regenerate token"
507            );
508            Ok(None)
509        }
510    }
511}
512
513fn ca_bundle_digest(bytes: &[u8]) -> String {
514    openssl::sha::sha256(bytes)
515        .iter()
516        .map(|byte| format!("{byte:02x}"))
517        .collect()
518}
519
520fn validate_ca_bundle_ref(ca_ref: &CaBundleRef) -> Result<()> {
521    if ca_ref.name.trim().is_empty() || ca_ref.key.trim().is_empty() {
522        return Err(Error::MissingData(
523            "spec.mailSender.caBundleRef requires a non-empty ConfigMap name and key".to_string(),
524        ));
525    }
526    Ok(())
527}
528
529fn ca_bundle_bytes<'a>(ca_ref: &CaBundleRef, config_map: &'a ConfigMap) -> Result<&'a [u8]> {
530    let bytes = config_map
531        .data
532        .as_ref()
533        .and_then(|data| data.get(&ca_ref.key).map(|pem| pem.as_bytes()))
534        .or_else(|| {
535            config_map
536                .binary_data
537                .as_ref()
538                .and_then(|data| data.get(&ca_ref.key).map(|pem| pem.0.as_slice()))
539        })
540        .filter(|pem| !pem.is_empty())
541        .ok_or_else(|| {
542            Error::MissingData(format!(
543                "mail sender CA ConfigMap {} has no non-empty key {}",
544                ca_ref.name, ca_ref.key
545            ))
546        })?;
547    if openssl::x509::X509::stack_from_pem(bytes)
548        .map_or(true, |certificates| certificates.is_empty())
549    {
550        return Err(Error::MissingData(format!(
551            "mail sender CA ConfigMap {} key {} must contain PEM certificates",
552            ca_ref.name, ca_ref.key
553        )));
554    }
555    Ok(bytes)
556}
557
558async fn mail_sender_ca_hash(
559    ctx: &Context,
560    namespace: &str,
561    ca_ref: Option<&CaBundleRef>,
562) -> Result<Option<String>> {
563    let Some(ca_ref) = ca_ref else {
564        return Ok(None);
565    };
566    validate_ca_bundle_ref(ca_ref)?;
567    let config_map_api: Api<ConfigMap> = Api::namespaced(ctx.kaniop_ctx.client.clone(), namespace);
568    let cm = config_map_api.get(&ca_ref.name).await.map_err(|e| {
569        Error::kube_error(
570            "get",
571            "mail sender CA ConfigMap",
572            namespace,
573            &ca_ref.name,
574            e,
575        )
576    })?;
577    Ok(Some(ca_bundle_digest(ca_bundle_bytes(ca_ref, &cm)?)))
578}
579
580fn create_config_secret(
581    kanidm: &Kanidm,
582    name: &str,
583    spec: &MailSenderSpec,
584    token: &str,
585    smtp_credentials: &SmtpCredentials,
586) -> Result<Secret> {
587    debug!(name, "creating config secret");
588
589    let domain = &kanidm.spec.domain;
590    let default_origin = format!("https://{domain}");
591    let origin = kanidm.spec.origin.as_ref().unwrap_or(&default_origin);
592    let default_display_name = format!("Kanidm {domain}");
593    let display_name = kanidm
594        .spec
595        .domain_appearance
596        .as_ref()
597        .and_then(|da| da.display_name.as_ref())
598        .unwrap_or(&default_display_name);
599    let poll_interval = spec
600        .queue_poll_interval_seconds
601        .unwrap_or(DEFAULT_QUEUE_POLL_INTERVAL);
602    let connect_timeout = spec
603        .connect_timeout_seconds
604        .unwrap_or(DEFAULT_CONNECT_TIMEOUT);
605
606    let mut client_config = format!("uri = {}", toml_basic_string(origin));
607    if spec.ca_bundle_ref.is_some() {
608        client_config.push_str(&format!(
609            "\nca_path = {}",
610            toml_basic_string(&ca_bundle_path())
611        ));
612    }
613
614    let reply_to = spec
615        .reply_to_address
616        .as_deref()
617        .unwrap_or(&spec.from_address);
618
619    let token = toml_basic_string(token);
620    let display_name = toml_basic_string(display_name);
621    let origin = toml_basic_string(origin);
622    let from_address = toml_basic_string(&spec.from_address);
623    let reply_to = toml_basic_string(reply_to);
624    let relay_host = toml_basic_string(&spec.relay);
625    let username = toml_basic_string(&smtp_credentials.username);
626    let password = toml_basic_string(&smtp_credentials.password);
627    let schedule = toml_basic_string(&format!("*/{poll_interval} * * * * * *"));
628
629    let mail_config = format!(
630        r#"token = {token}
631instance_display_name = {display_name}
632instance_url = {origin}
633mail_from_address = {from_address}
634mail_reply_to_address = {reply_to}
635mail_relay = {relay_host}
636mail_username = {username}
637mail_password = {password}
638mail_connect_timeout_seconds = {connect_timeout}
639schedule = {schedule}
640"#
641    );
642
643    let extended_labels = generate_extended_mail_sender_labels(kanidm);
644
645    Ok(Secret {
646        metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta {
647            name: Some(name.to_string()),
648            namespace: Some(kanidm.namespace().unwrap()),
649            owner_references: kanidm.controller_owner_ref(&()).map(|oref| vec![oref]),
650            labels: Some(extended_labels),
651            ..Default::default()
652        },
653        string_data: Some(BTreeMap::from([
654            (CLIENT_CONFIG_KEY.to_string(), client_config),
655            (MAIL_CONFIG_KEY.to_string(), mail_config),
656        ])),
657        type_: Some("Opaque".to_string()),
658        ..Default::default()
659    })
660}
661
662// Follow Kanidm's Docker Hub release convention: server:<tag> -> tools:<tag>.
663// Image digests identify individual artifacts and must never be carried from
664// the server image into the separate tools image. The explicit mailSender.image
665// always takes precedence over this default.
666fn default_mail_sender_image(server_image: &str) -> Result<String> {
667    let tag = match kaniop_k8s_util::resources::get_image_tag(server_image) {
668        Some(tag) => tag,
669        None if !server_image.contains('@') => "latest".to_string(),
670        None => {
671            return Err(Error::MissingData(
672                "Cannot infer a mail sender image tag from the Kanidm server image; set spec.mailSender.image explicitly".to_string(),
673            ));
674        }
675    };
676
677    Ok(format!("kanidm/tools:{tag}"))
678}
679
680fn create_deployment(
681    kanidm: &Kanidm,
682    name: &str,
683    spec: &MailSenderSpec,
684    config_secret_name: &str,
685    ca_hash: Option<&str>,
686) -> Result<Deployment> {
687    debug!(name, "creating deployment");
688
689    let namespace = kanidm.namespace().unwrap();
690    let image = match &spec.image {
691        Some(image) => image.clone(),
692        None => default_mail_sender_image(&kanidm.spec.image)?,
693    };
694
695    let extended_labels = generate_extended_mail_sender_labels(kanidm);
696
697    let mut container = Container {
698        name: MAIL_SENDER_COMPONENT.to_string(),
699        image: Some(image),
700        image_pull_policy: kanidm.spec.image_pull_policy.clone(),
701        command: Some(vec![
702            "/sbin/kanidm-mail-sender".to_string(),
703            "-c".to_string(),
704            format!("/data/config/{CLIENT_CONFIG_KEY}"),
705            "-m".to_string(),
706            format!("/data/config/{MAIL_CONFIG_KEY}"),
707        ]),
708        resources: spec.resources.clone(),
709        volume_mounts: Some(vec![VolumeMount {
710            name: "config".to_string(),
711            mount_path: "/data/config".to_string(),
712            read_only: Some(true),
713            ..Default::default()
714        }]),
715        ..Default::default()
716    };
717
718    if spec.ca_bundle_ref.is_some() {
719        container
720            .volume_mounts
721            .get_or_insert_with(Vec::new)
722            .push(build_ca_bundle_volume_mount());
723    }
724
725    let mut pod_spec = PodSpec {
726        containers: vec![container],
727        security_context: Some(kanidm.spec.security_context.clone().unwrap_or_else(|| {
728            PodSecurityContext {
729                run_as_non_root: Some(true),
730                run_as_user: Some(65534),
731                ..Default::default()
732            }
733        })),
734        volumes: Some(vec![Volume {
735            name: "config".to_string(),
736            secret: Some(SecretVolumeSource {
737                secret_name: Some(config_secret_name.to_string()),
738                items: Some(vec![
739                    KeyToPath {
740                        key: CLIENT_CONFIG_KEY.to_string(),
741                        path: CLIENT_CONFIG_KEY.to_string(),
742                        ..Default::default()
743                    },
744                    KeyToPath {
745                        key: MAIL_CONFIG_KEY.to_string(),
746                        path: MAIL_CONFIG_KEY.to_string(),
747                        ..Default::default()
748                    },
749                ]),
750                ..Default::default()
751            }),
752            ..Default::default()
753        }]),
754        node_selector: spec.node_selector.clone(),
755        affinity: spec.affinity.clone(),
756        tolerations: spec.tolerations.clone(),
757        automount_service_account_token: Some(false),
758        ..Default::default()
759    };
760
761    if let Some(ca_bundle_ref) = &spec.ca_bundle_ref {
762        pod_spec
763            .volumes
764            .get_or_insert_with(Vec::new)
765            .push(build_ca_bundle_volume(ca_bundle_ref));
766    }
767
768    let pod_template = PodTemplateSpec {
769        metadata: Some(k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta {
770            labels: Some(extended_labels.clone()),
771            annotations: ca_hash.map(|hash| {
772                BTreeMap::from([(MAIL_SENDER_CA_HASH_ANNOTATION.to_string(), hash.to_string())])
773            }),
774            ..Default::default()
775        }),
776        spec: Some(pod_spec),
777    };
778
779    Ok(Deployment {
780        metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta {
781            name: Some(name.to_string()),
782            namespace: Some(namespace),
783            owner_references: kanidm.controller_owner_ref(&()).map(|oref| vec![oref]),
784            labels: Some(extended_labels.clone()),
785            ..Default::default()
786        },
787        spec: Some(DeploymentSpec {
788            replicas: Some(1),
789            selector: k8s_openapi::apimachinery::pkg::apis::meta::v1::LabelSelector {
790                match_labels: Some(extended_labels),
791                ..Default::default()
792            },
793            template: pod_template,
794            strategy: Some(DeploymentStrategy {
795                type_: Some("Recreate".to_string()),
796                ..Default::default()
797            }),
798            ..Default::default()
799        }),
800        ..Default::default()
801    })
802}
803
804struct SmtpCredentials {
805    username: String,
806    password: String,
807}
808
809async fn read_smtp_credentials(
810    ctx: &Context,
811    spec: &MailSenderSpec,
812    namespace: &str,
813) -> Result<SmtpCredentials> {
814    let secret_api: Api<Secret> = Api::namespaced(ctx.kaniop_ctx.client.clone(), namespace);
815    let secret = secret_api
816        .get(&spec.credentials_secret.name)
817        .await
818        .map_err(|e| {
819            Error::kube_error(
820                "get",
821                "SMTP credentials secret",
822                namespace,
823                &spec.credentials_secret.name,
824                e,
825            )
826        })?;
827
828    let username_key = &spec.credentials_secret.username_key;
829    let password_key = &spec.credentials_secret.password_key;
830
831    let get_string = |key: &str| -> Result<String> {
832        secret
833            .string_data
834            .as_ref()
835            .and_then(|d| d.get(key).cloned())
836            .or_else(|| {
837                secret
838                    .data
839                    .as_ref()
840                    .and_then(|d| d.get(key))
841                    .map(|v| String::from_utf8_lossy(&v.0).to_string())
842            })
843            .ok_or_else(|| {
844                Error::MissingData(format!(
845                    "SMTP credentials secret {} missing key {}",
846                    spec.credentials_secret.name, key
847                ))
848            })
849    };
850
851    Ok(SmtpCredentials {
852        username: get_string(username_key)?,
853        password: get_string(password_key)?,
854    })
855}
856
857pub async fn cleanup_mail_sender_resources(kanidm: &Kanidm, ctx: &Context) -> Result<bool> {
858    let namespace = kanidm.namespace().unwrap();
859    let kanidm_name = kanidm.name_any();
860    let mut changed = false;
861
862    let deployment_name = mail_sender_deployment_name(&kanidm_name);
863    let config_secret_name = mail_sender_config_map_name(&kanidm_name);
864
865    let deployment_api: Api<Deployment> =
866        Api::namespaced(ctx.kaniop_ctx.client.clone(), &namespace);
867    let secret_api: Api<k8s_openapi::api::core::v1::Secret> =
868        Api::namespaced(ctx.kaniop_ctx.client.clone(), &namespace);
869
870    let dp = DeleteParams::default();
871
872    match deployment_api.delete(&deployment_name, &dp).await {
873        Ok(_) => {
874            changed = true;
875        }
876        Err(kube::Error::Api(e)) if e.code == 404 => {
877            debug!(deployment_name, "mail sender deployment already absent");
878        }
879        Err(e) => {
880            return Err(Error::kube_error(
881                "delete",
882                "deployment",
883                &namespace,
884                &deployment_name,
885                e,
886            ));
887        }
888    }
889
890    match secret_api.delete(&config_secret_name, &dp).await {
891        Ok(_) => {
892            changed = true;
893        }
894        Err(kube::Error::Api(e)) if e.code == 404 => {
895            debug!(
896                config_secret_name,
897                "mail sender config secret already absent"
898            );
899        }
900        Err(e) => {
901            return Err(Error::kube_error(
902                "delete",
903                "secret",
904                &namespace,
905                &config_secret_name,
906                e,
907            ));
908        }
909    }
910
911    Ok(changed)
912}
913
914pub async fn cleanup_mail_sender_in_kanidm(
915    kanidm_client: &KanidmClient,
916    kanidm_name: &str,
917    metrics: &crate::metrics::ControllerMetrics,
918) -> Result<bool> {
919    let sa_name = mail_sender_service_account_name(kanidm_name);
920    let mut changed = false;
921
922    debug!(sa_name, "removing mail sender from message_senders group");
923    let start = tokio::time::Instant::now();
924    let remove_result = kanidm_client
925        .idm_group_remove_members(MESSAGE_SENDERS_GROUP, &[&sa_name])
926        .await;
927    match remove_result {
928        Ok(()) => {
929            metrics.record_kanidm_sdk_outcome(
930                KANIDM_RESOURCE_MAIL_SENDER,
931                KANIDM_OP_REMOVE_MEMBERS,
932                KANIDM_OUTCOME_CHANGED,
933                start.elapsed(),
934            );
935            changed = true;
936        }
937        Err(e) if is_not_found_error(&e) || is_not_a_member_error(&e) => {
938            debug!(sa_name, "mail sender group membership already absent");
939            metrics.record_kanidm_sdk_outcome(
940                KANIDM_RESOURCE_MAIL_SENDER,
941                KANIDM_OP_REMOVE_MEMBERS,
942                KANIDM_OUTCOME_UNCHANGED,
943                start.elapsed(),
944            );
945        }
946        Err(e) => {
947            metrics.record_kanidm_sdk_outcome(
948                KANIDM_RESOURCE_MAIL_SENDER,
949                KANIDM_OP_REMOVE_MEMBERS,
950                KANIDM_OUTCOME_ERROR,
951                start.elapsed(),
952            );
953            return Err(Error::KanidmClientError(
954                format!("failed to remove {sa_name} from {MESSAGE_SENDERS_GROUP}"),
955                Box::new(e),
956            ));
957        }
958    }
959
960    debug!(sa_name, "deleting mail sender service account");
961    let start = tokio::time::Instant::now();
962    let delete_result = kanidm_client.idm_service_account_delete(&sa_name).await;
963    match delete_result {
964        Ok(()) => {
965            metrics.record_kanidm_sdk_outcome(
966                KANIDM_RESOURCE_MAIL_SENDER,
967                KANIDM_OP_DELETE,
968                KANIDM_OUTCOME_CHANGED,
969                start.elapsed(),
970            );
971            changed = true;
972        }
973        Err(e) if is_not_found_error(&e) => {
974            debug!(sa_name, "mail sender service account already absent");
975            metrics.record_kanidm_sdk_outcome(
976                KANIDM_RESOURCE_MAIL_SENDER,
977                KANIDM_OP_DELETE,
978                KANIDM_OUTCOME_UNCHANGED,
979                start.elapsed(),
980            );
981        }
982        Err(e) => {
983            metrics.record_kanidm_sdk_outcome(
984                KANIDM_RESOURCE_MAIL_SENDER,
985                KANIDM_OP_DELETE,
986                KANIDM_OUTCOME_ERROR,
987                start.elapsed(),
988            );
989            return Err(Error::KanidmClientError(
990                format!("failed to delete service account {sa_name}"),
991                Box::new(e),
992            ));
993        }
994    }
995
996    Ok(changed)
997}
998
999fn is_already_exists_error(e: &kanidm_client::ClientError) -> bool {
1000    match e {
1001        kanidm_client::ClientError::Http(status, _, body) => {
1002            status.as_u16() == 409
1003                || body.contains("already exists")
1004                || body.contains("conflicting_with")
1005                || body.contains("AttributeUniqueness")
1006        }
1007        _ => false,
1008    }
1009}
1010
1011fn is_not_found_error(e: &kanidm_client::ClientError) -> bool {
1012    match e {
1013        ClientError::Http(status, operation_error, body) => {
1014            status.as_u16() == 404
1015                || operation_error == &Some(OperationError::NoMatchingEntries)
1016                || body.contains("NoMatchingEntries")
1017                || body.contains("not found")
1018                || body.contains("does not exist")
1019        }
1020        _ => false,
1021    }
1022}
1023
1024fn is_not_a_member_error(e: &kanidm_client::ClientError) -> bool {
1025    match e {
1026        ClientError::Http(_, _, body) => body.contains("not a member"),
1027        _ => false,
1028    }
1029}
1030
1031fn toml_basic_string(value: &str) -> String {
1032    let mut output = String::with_capacity(value.len() + 2);
1033    output.push('"');
1034    for c in value.chars() {
1035        match c {
1036            '\u{08}' => output.push_str("\\b"),
1037            '\t' => output.push_str("\\t"),
1038            '\n' => output.push_str("\\n"),
1039            '\u{0c}' => output.push_str("\\f"),
1040            '\r' => output.push_str("\\r"),
1041            '"' => output.push_str("\\\""),
1042            '\\' => output.push_str("\\\\"),
1043            c if c.is_control() => {
1044                let code = c as u32;
1045                if code <= 0xffff {
1046                    output.push_str(&format!("\\u{code:04X}"));
1047                } else {
1048                    output.push_str(&format!("\\U{code:08X}"));
1049                }
1050            }
1051            c => output.push(c),
1052        }
1053    }
1054    output.push('"');
1055    output
1056}
1057
1058fn generate_mail_sender_labels(kanidm: &Kanidm) -> BTreeMap<String, String> {
1059    BTreeMap::from([
1060        (NAME_LABEL.to_string(), "kanidm".to_string()),
1061        (
1062            MANAGED_BY_LABEL.to_string(),
1063            format!("kaniop-{}", super::super::controller::CONTROLLER_ID),
1064        ),
1065        (INSTANCE_LABEL.to_string(), kanidm.name_any()),
1066        (CLUSTER_LABEL.to_string(), kanidm.name_any()),
1067    ])
1068}
1069
1070fn generate_extended_mail_sender_labels(kanidm: &Kanidm) -> BTreeMap<String, String> {
1071    generate_mail_sender_labels(kanidm)
1072        .into_iter()
1073        .chain([
1074            (MAIL_SENDER_LABEL.to_string(), kanidm.name_any()),
1075            (NAME_LABEL.to_string(), MAIL_SENDER_COMPONENT.to_string()),
1076        ])
1077        .collect()
1078}
1079
1080#[cfg(test)]
1081mod tests {
1082    use super::{
1083        create_deployment, default_mail_sender_image, group_contains_member, toml_basic_string,
1084    };
1085    use crate::kanidm::crd::{CaBundleRef, Kanidm, MailSenderSpec};
1086    use k8s_openapi::api::core::v1::ConfigMap;
1087    use kanidm_client::KanidmClientBuilder;
1088    use openssl::asn1::Asn1Time;
1089    use openssl::bn::BigNum;
1090    use openssl::hash::MessageDigest;
1091    use openssl::pkey::{PKey, Private};
1092    use openssl::rsa::Rsa;
1093    use openssl::ssl::{SslAcceptor, SslMethod};
1094    use openssl::x509::extension::{BasicConstraints, KeyUsage, SubjectAlternativeName};
1095    use openssl::x509::{X509, X509NameBuilder};
1096    use serde_json::json;
1097    use std::io::{Read, Write};
1098    use std::net::TcpListener;
1099
1100    fn tls_test_certificates() -> (Vec<u8>, Vec<u8>, Vec<u8>) {
1101        let ca_key = PKey::from_rsa(Rsa::generate(2048).unwrap()).unwrap();
1102        let mut ca_name = X509NameBuilder::new().unwrap();
1103        ca_name
1104            .append_entry_by_text("CN", "Kaniop Test CA")
1105            .unwrap();
1106        let ca_name = ca_name.build();
1107        let mut ca_builder = X509::builder().unwrap();
1108        ca_builder.set_version(2).unwrap();
1109        let serial = BigNum::from_u32(1).unwrap().to_asn1_integer().unwrap();
1110        ca_builder.set_serial_number(&serial).unwrap();
1111        ca_builder.set_subject_name(&ca_name).unwrap();
1112        ca_builder.set_issuer_name(&ca_name).unwrap();
1113        ca_builder.set_pubkey(&ca_key).unwrap();
1114        ca_builder
1115            .set_not_before(&Asn1Time::days_from_now(0).unwrap())
1116            .unwrap();
1117        ca_builder
1118            .set_not_after(&Asn1Time::days_from_now(2).unwrap())
1119            .unwrap();
1120        ca_builder
1121            .append_extension(BasicConstraints::new().critical().ca().build().unwrap())
1122            .unwrap();
1123        ca_builder
1124            .append_extension(
1125                KeyUsage::new()
1126                    .critical()
1127                    .key_cert_sign()
1128                    .crl_sign()
1129                    .build()
1130                    .unwrap(),
1131            )
1132            .unwrap();
1133        ca_builder.sign(&ca_key, MessageDigest::sha256()).unwrap();
1134        let ca = ca_builder.build();
1135
1136        let leaf_key = PKey::from_rsa(Rsa::generate(2048).unwrap()).unwrap();
1137        let mut leaf_name = X509NameBuilder::new().unwrap();
1138        leaf_name.append_entry_by_text("CN", "localhost").unwrap();
1139        let leaf_name = leaf_name.build();
1140        let mut leaf_builder = X509::builder().unwrap();
1141        leaf_builder.set_version(2).unwrap();
1142        let serial = BigNum::from_u32(2).unwrap().to_asn1_integer().unwrap();
1143        leaf_builder.set_serial_number(&serial).unwrap();
1144        leaf_builder.set_subject_name(&leaf_name).unwrap();
1145        leaf_builder.set_issuer_name(ca.subject_name()).unwrap();
1146        leaf_builder.set_pubkey(&leaf_key).unwrap();
1147        leaf_builder
1148            .set_not_before(&Asn1Time::days_from_now(0).unwrap())
1149            .unwrap();
1150        leaf_builder
1151            .set_not_after(&Asn1Time::days_from_now(2).unwrap())
1152            .unwrap();
1153        leaf_builder
1154            .append_extension(BasicConstraints::new().critical().build().unwrap())
1155            .unwrap();
1156        leaf_builder
1157            .append_extension(
1158                KeyUsage::new()
1159                    .critical()
1160                    .digital_signature()
1161                    .key_encipherment()
1162                    .build()
1163                    .unwrap(),
1164            )
1165            .unwrap();
1166        let san = SubjectAlternativeName::new()
1167            .dns("localhost")
1168            .build(&leaf_builder.x509v3_context(Some(&ca), None))
1169            .unwrap();
1170        leaf_builder.append_extension(san).unwrap();
1171        leaf_builder.sign(&ca_key, MessageDigest::sha256()).unwrap();
1172        (
1173            ca.to_pem().unwrap(),
1174            leaf_builder.build().to_pem().unwrap(),
1175            leaf_key.private_key_to_pem_pkcs8().unwrap(),
1176        )
1177    }
1178
1179    #[test]
1180    fn ca_rotation_changes_pod_template_hash_only_for_selected_key() {
1181        let (ca_pem, _, _) = tls_test_certificates();
1182        let (other_ca_pem, _, _) = tls_test_certificates();
1183        let ca_ref = CaBundleRef {
1184            name: "private-pki".into(),
1185            key: "ca.crt".into(),
1186        };
1187        let mut cm = ConfigMap {
1188            data: Some(
1189                [
1190                    ("ca.crt".to_string(), String::from_utf8(ca_pem).unwrap()),
1191                    ("other".to_string(), "original".to_string()),
1192                ]
1193                .into(),
1194            ),
1195            ..Default::default()
1196        };
1197        let first_hash = super::ca_bundle_digest(super::ca_bundle_bytes(&ca_ref, &cm).unwrap());
1198        cm.data
1199            .as_mut()
1200            .unwrap()
1201            .insert("other".into(), "updated".into());
1202        let same_hash = super::ca_bundle_digest(super::ca_bundle_bytes(&ca_ref, &cm).unwrap());
1203        assert_eq!(first_hash, same_hash);
1204        cm.data
1205            .as_mut()
1206            .unwrap()
1207            .insert("ca.crt".into(), String::from_utf8(other_ca_pem).unwrap());
1208        let new_hash = super::ca_bundle_digest(super::ca_bundle_bytes(&ca_ref, &cm).unwrap());
1209        assert_ne!(first_hash, new_hash);
1210
1211        let kanidm: Kanidm = serde_json::from_value(json!({
1212            "apiVersion": "kaniop.rs/v1beta1", "kind": "Kanidm",
1213            "metadata": {"name": "idm", "namespace": "default"},
1214            "spec": {"domain": "idm.example.com",
1215                     "replicaGroups": [{"name": "default", "replicas": 1}]}
1216        }))
1217        .unwrap();
1218        let spec: MailSenderSpec = serde_json::from_value(json!({
1219            "relay": "smtps://smtp.example.com",
1220            "credentialsSecret": {"name": "smtp-credentials"},
1221            "fromAddress": "kanidm@example.com",
1222            "caBundleRef": {"name": "private-pki", "key": "ca.crt"}
1223        }))
1224        .unwrap();
1225        let template_hash = |hash: &str| {
1226            let deployment = create_deployment(
1227                &kanidm,
1228                "idm-mail-sender",
1229                &spec,
1230                "idm-mail-sender-config",
1231                Some(hash),
1232            )
1233            .unwrap();
1234            deployment
1235                .spec
1236                .unwrap()
1237                .template
1238                .metadata
1239                .unwrap()
1240                .annotations
1241                .unwrap()[super::MAIL_SENDER_CA_HASH_ANNOTATION]
1242                .clone()
1243        };
1244        assert_eq!(template_hash(&first_hash), template_hash(&same_hash));
1245        assert_ne!(template_hash(&first_hash), template_hash(&new_hash));
1246    }
1247
1248    #[test]
1249    fn invalid_ca_reference_and_missing_key_are_rejected() {
1250        for (name, key) in [("", "ca.crt"), ("private-pki", ""), ("  ", "  ")] {
1251            assert!(
1252                super::validate_ca_bundle_ref(&CaBundleRef {
1253                    name: name.to_string(),
1254                    key: key.to_string(),
1255                })
1256                .is_err()
1257            );
1258        }
1259        let ca_ref = CaBundleRef {
1260            name: "private-pki".into(),
1261            key: "ca.crt".into(),
1262        };
1263        let empty = ConfigMap::default();
1264        assert!(super::ca_bundle_bytes(&ca_ref, &empty).is_err());
1265        let invalid = ConfigMap {
1266            data: Some([("ca.crt".into(), "not a PEM".into())].into()),
1267            ..Default::default()
1268        };
1269        assert!(super::ca_bundle_bytes(&ca_ref, &invalid).is_err());
1270    }
1271
1272    #[tokio::test]
1273    async fn private_ca_allows_verified_https_from_generated_client_config() {
1274        let (ca_pem, server_cert, server_key) = tls_test_certificates();
1275        let listener = TcpListener::bind("127.0.0.1:0").unwrap();
1276        let url = format!(
1277            "https://localhost:{}",
1278            listener.local_addr().unwrap().port()
1279        );
1280        let server =
1281            std::thread::spawn(move || {
1282                let key = PKey::<Private>::private_key_from_pem(&server_key).unwrap();
1283                let cert = X509::from_pem(&server_cert).unwrap();
1284                let mut acceptor = SslAcceptor::mozilla_intermediate(SslMethod::tls()).unwrap();
1285                acceptor.set_private_key(&key).unwrap();
1286                acceptor.set_certificate(&cert).unwrap();
1287                acceptor.check_private_key().unwrap();
1288                let acceptor = acceptor.build();
1289                for _ in 0..2 {
1290                    let (stream, _) = listener.accept().unwrap();
1291                    stream
1292                        .set_read_timeout(Some(std::time::Duration::from_secs(5)))
1293                        .unwrap();
1294                    if let Ok(mut connection) = acceptor.accept(stream) {
1295                        let mut request = [0u8; 2048];
1296                        let _ = connection.read(&mut request);
1297                        connection.write_all(
1298                        b"HTTP/1.1 200 OK\r\nContent-Length: 2\r\nConnection: close\r\n\r\nOK",
1299                    ).unwrap();
1300                    }
1301                }
1302            });
1303
1304        let tmp = tempfile::tempdir().unwrap();
1305        let ca_file = tmp.path().join("ca.pem");
1306        std::fs::write(&ca_file, ca_pem).unwrap();
1307        let config_file = tmp.path().join("client.toml");
1308        let mut kanidm: Kanidm = serde_json::from_value(json!({
1309            "apiVersion": "kaniop.rs/v1beta1", "kind": "Kanidm",
1310            "metadata": {"name": "idm", "namespace": "default"},
1311            "spec": {"domain": "idm.example.com",
1312                     "replicaGroups": [{"name": "default", "replicas": 1}]}
1313        }))
1314        .unwrap();
1315        kanidm.spec.origin = Some(url.clone());
1316        let mut spec: MailSenderSpec = serde_json::from_value(json!({
1317            "relay": "smtps://smtp.example.com",
1318            "credentialsSecret": {"name": "smtp-credentials"},
1319            "fromAddress": "kanidm@example.com"
1320        }))
1321        .unwrap();
1322        let credentials = super::SmtpCredentials {
1323            username: "smtp-user".into(),
1324            password: "smtp-password".into(),
1325        };
1326        let generated = |spec: &MailSenderSpec| {
1327            super::create_config_secret(
1328                &kanidm,
1329                "idm-mail-sender-config",
1330                spec,
1331                "token",
1332                &credentials,
1333            )
1334            .unwrap()
1335            .string_data
1336            .unwrap()[super::CLIENT_CONFIG_KEY]
1337                .clone()
1338        };
1339        std::fs::write(&config_file, generated(&spec)).unwrap();
1340        let untrusted = KanidmClientBuilder::new()
1341            .no_proxy()
1342            .read_options_from_optional_config(&config_file)
1343            .unwrap()
1344            .build()
1345            .unwrap();
1346        assert!(
1347            untrusted.client().get(&url).send().await.is_err(),
1348            "untrusted CA must fail verification"
1349        );
1350
1351        spec.ca_bundle_ref = Some(CaBundleRef {
1352            name: "private-pki".into(),
1353            key: "ca.crt".into(),
1354        });
1355        // The production path is a projected ConfigMap. Replace only that path
1356        // with an equivalent test-mounted PEM file.
1357        let config = generated(&spec).replace(
1358            kaniop_backup_core::auth::CA_BUNDLE_MOUNT_PATH,
1359            ca_file.to_str().unwrap(),
1360        );
1361        assert!(config.contains("ca_path = "));
1362        std::fs::write(&config_file, config).unwrap();
1363        let trusted = KanidmClientBuilder::new()
1364            .no_proxy()
1365            .read_options_from_optional_config(&config_file)
1366            .unwrap()
1367            .build()
1368            .unwrap();
1369        let response = trusted.client().get(&url).send().await.unwrap();
1370        assert!(response.status().is_success());
1371        server.join().unwrap();
1372    }
1373
1374    #[test]
1375    fn custom_ca_bundle_configures_mail_sender_client_and_pod() {
1376        let kanidm: Kanidm = serde_json::from_value(json!({
1377            "apiVersion": "kaniop.rs/v1beta1",
1378            "kind": "Kanidm",
1379            "metadata": {"name": "idm", "namespace": "default"},
1380            "spec": {
1381                "domain": "idm.example.com",
1382                "replicaGroups": [{"name": "default", "replicas": 1}]
1383            }
1384        }))
1385        .unwrap();
1386        let mut spec: MailSenderSpec = serde_json::from_value(json!({
1387            "relay": "smtps://smtp.example.com",
1388            "credentialsSecret": {"name": "smtp-credentials"},
1389            "fromAddress": "kanidm@example.com",
1390            "caBundleRef": {"name": "private-pki", "key": "ca.crt"}
1391        }))
1392        .unwrap();
1393        let credentials = super::SmtpCredentials {
1394            username: "smtp-user".to_string(),
1395            password: "smtp-password".to_string(),
1396        };
1397
1398        // Use Kanidm's native client trust setting, without disabling TLS verification.
1399        let secret = super::create_config_secret(
1400            &kanidm,
1401            "idm-mail-sender-config",
1402            &spec,
1403            "token",
1404            &credentials,
1405        )
1406        .unwrap();
1407        let config = secret.string_data.unwrap();
1408        assert_eq!(
1409            config[super::CLIENT_CONFIG_KEY],
1410            format!(
1411                "uri = \"https://idm.example.com\"\nca_path = \"{}\"",
1412                kaniop_backup_core::auth::CA_BUNDLE_MOUNT_PATH
1413            )
1414        );
1415        let deployment = create_deployment(
1416            &kanidm,
1417            "idm-mail-sender",
1418            &spec,
1419            "idm-mail-sender-config",
1420            None,
1421        )
1422        .unwrap();
1423        let pod = deployment.spec.unwrap().template.spec.unwrap();
1424        let volume = pod
1425            .volumes
1426            .as_ref()
1427            .unwrap()
1428            .iter()
1429            .find(|volume| volume.name == kaniop_backup_core::auth::CA_BUNDLE_VOLUME_NAME)
1430            .unwrap();
1431        let cm = volume.config_map.as_ref().unwrap();
1432        assert_eq!(cm.name, "private-pki");
1433        assert_eq!(cm.items.as_ref().unwrap()[0].key, "ca.crt");
1434        assert_eq!(
1435            cm.items.as_ref().unwrap()[0].path,
1436            kaniop_backup_core::auth::CA_BUNDLE_FILE_NAME
1437        );
1438        let mount = pod.containers[0]
1439            .volume_mounts
1440            .as_ref()
1441            .unwrap()
1442            .iter()
1443            .find(|mount| mount.name == kaniop_backup_core::auth::CA_BUNDLE_VOLUME_NAME)
1444            .unwrap();
1445        assert_eq!(
1446            mount.mount_path,
1447            kaniop_backup_core::auth::CA_BUNDLE_MOUNT_DIR
1448        );
1449        assert_eq!(mount.read_only, Some(true));
1450        assert_eq!(pod.volumes.as_ref().unwrap().len(), 2);
1451
1452        // Removing the reference restores the previous manifest and client configuration.
1453        spec.ca_bundle_ref = None;
1454        let secret = super::create_config_secret(
1455            &kanidm,
1456            "idm-mail-sender-config",
1457            &spec,
1458            "token",
1459            &credentials,
1460        )
1461        .unwrap();
1462        assert_eq!(
1463            secret.string_data.unwrap()[super::CLIENT_CONFIG_KEY],
1464            "uri = \"https://idm.example.com\""
1465        );
1466        let deployment = create_deployment(
1467            &kanidm,
1468            "idm-mail-sender",
1469            &spec,
1470            "idm-mail-sender-config",
1471            None,
1472        )
1473        .unwrap();
1474        let pod = deployment.spec.unwrap().template.spec.unwrap();
1475        assert_eq!(pod.volumes.as_ref().unwrap().len(), 1);
1476        assert_eq!(pod.containers[0].volume_mounts.as_ref().unwrap().len(), 1);
1477    }
1478
1479    #[test]
1480    fn ca_bundle_ref_requires_a_configmap_name_and_key() {
1481        assert!(
1482            serde_json::from_value::<MailSenderSpec>(json!({
1483                "relay": "smtps://smtp.example.com",
1484                "credentialsSecret": {"name": "smtp-credentials"},
1485                "fromAddress": "kanidm@example.com",
1486                "caBundleRef": {"name": "private-pki"}
1487            }))
1488            .is_err()
1489        );
1490    }
1491
1492    #[test]
1493    fn digest_pinned_server_image_creates_pullable_mail_sender_deployment() {
1494        // Use the exact tagged-and-digest-pinned input shape from issue #1110.
1495        let kanidm: Kanidm = serde_json::from_value(json!({
1496            "apiVersion": "kaniop.rs/v1beta1",
1497            "kind": "Kanidm",
1498            "metadata": {"name": "idm", "namespace": "default"},
1499            "spec": {
1500                "domain": "idm.example.com",
1501                "image": "kanidm/server:1.11.2@sha256:deadbeef",
1502                "replicaGroups": [{"name": "default", "replicas": 1}]
1503            }
1504        }))
1505        .unwrap();
1506        let mail_sender_spec: MailSenderSpec = serde_json::from_value(json!({
1507            "relay": "smtps://smtp.example.com",
1508            "credentialsSecret": {"name": "smtp-credentials"},
1509            "fromAddress": "kanidm@example.com"
1510        }))
1511        .unwrap();
1512
1513        let deployment = create_deployment(
1514            &kanidm,
1515            "idm-mail-sender",
1516            &mail_sender_spec,
1517            "idm-mail-sender-config",
1518            None,
1519        )
1520        .unwrap();
1521
1522        let image = deployment.spec.unwrap().template.spec.unwrap().containers[0]
1523            .image
1524            .clone();
1525        assert_eq!(image.as_deref(), Some("kanidm/tools:1.11.2"));
1526        assert!(!image.unwrap().contains("@sha256:"));
1527
1528        // An override is an exact image reference, including its own digest.
1529        // It must not be parsed, rewritten or constrained by the server image.
1530        let override_image = "mirror.example.org/custom/mail-sender:custom@sha256:abcdef";
1531        let mut overridden = mail_sender_spec;
1532        overridden.image = Some(override_image.to_string());
1533        let deployment = create_deployment(
1534            &kanidm,
1535            "idm-mail-sender",
1536            &overridden,
1537            "idm-mail-sender-config",
1538            None,
1539        )
1540        .unwrap();
1541        assert_eq!(
1542            deployment.spec.unwrap().template.spec.unwrap().containers[0]
1543                .image
1544                .as_deref(),
1545            Some(override_image),
1546        );
1547
1548        // Even a digest-only server image can be used with an explicit override.
1549        let mut digest_only_server = kanidm;
1550        digest_only_server.spec.image = "kanidm/server@sha256:deadbeef".to_string();
1551        let deployment = create_deployment(
1552            &digest_only_server,
1553            "idm-mail-sender",
1554            &overridden,
1555            "idm-mail-sender-config",
1556            None,
1557        )
1558        .unwrap();
1559        assert_eq!(
1560            deployment.spec.unwrap().template.spec.unwrap().containers[0]
1561                .image
1562                .as_deref(),
1563            Some(override_image),
1564        );
1565    }
1566
1567    #[test]
1568    fn default_mail_sender_image_uses_docker_hub_versioned_tools() {
1569        for (server, expected) in [
1570            ("kanidm/server:1.11.2", "kanidm/tools:1.11.2"),
1571            ("kanidm/server:latest", "kanidm/tools:latest"),
1572            ("kanidm/server", "kanidm/tools:latest"),
1573            (
1574                "kanidm/server:1.11.2@sha256:deadbeef",
1575                "kanidm/tools:1.11.2",
1576            ),
1577        ] {
1578            assert_eq!(default_mail_sender_image(server).unwrap(), expected);
1579        }
1580    }
1581
1582    #[test]
1583    fn digest_only_server_image_requires_explicit_mail_sender_image() {
1584        assert!(default_mail_sender_image("kanidm/server@sha256:deadbeef").is_err());
1585    }
1586
1587    #[test]
1588    fn toml_basic_string_escapes_config_values() {
1589        assert_eq!(
1590            toml_basic_string("quoted \"value\" with \\ slash\nand tab\t"),
1591            r#""quoted \"value\" with \\ slash\nand tab\t""#
1592        );
1593    }
1594
1595    #[test]
1596    fn group_contains_member_matches_bare_name_against_spn() {
1597        let members = vec![
1598            "other-user".to_string(),
1599            "my-sa@idm.example.com".to_string(),
1600        ];
1601        assert!(group_contains_member(&members, "my-sa"));
1602    }
1603
1604    #[test]
1605    fn group_contains_member_is_case_insensitive() {
1606        let members = vec!["My-SA@idm.example.com".to_string()];
1607        assert!(group_contains_member(&members, "my-sa"));
1608    }
1609
1610    #[test]
1611    fn group_contains_member_returns_false_for_empty() {
1612        let members: Vec<String> = vec![];
1613        assert!(!group_contains_member(&members, "my-sa"));
1614    }
1615
1616    #[test]
1617    fn group_contains_member_returns_false_when_no_match() {
1618        let members = vec![
1619            "other-user".to_string(),
1620            "another-sa@idm.example.com".to_string(),
1621        ];
1622        assert!(!group_contains_member(&members, "my-sa"));
1623    }
1624}