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, EnvVar, 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.as_ref(),
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: Option<&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 smtp_auth_config = smtp_credentials.map_or_else(String::new, |credentials| {
626        format!(
627            "mail_username = {}\nmail_password = {}\n",
628            toml_basic_string(&credentials.username),
629            toml_basic_string(&credentials.password)
630        )
631    });
632    let schedule = toml_basic_string(&format!("*/{poll_interval} * * * * * *"));
633
634    let mail_config = format!(
635        r#"token = {token}
636instance_display_name = {display_name}
637instance_url = {origin}
638mail_from_address = {from_address}
639mail_reply_to_address = {reply_to}
640mail_relay = {relay_host}
641{smtp_auth_config}mail_connect_timeout_seconds = {connect_timeout}
642schedule = {schedule}
643"#
644    );
645
646    let extended_labels = generate_extended_mail_sender_labels(kanidm);
647
648    Ok(Secret {
649        metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta {
650            name: Some(name.to_string()),
651            namespace: Some(kanidm.namespace().unwrap()),
652            owner_references: kanidm.controller_owner_ref(&()).map(|oref| vec![oref]),
653            labels: Some(extended_labels),
654            ..Default::default()
655        },
656        string_data: Some(BTreeMap::from([
657            (CLIENT_CONFIG_KEY.to_string(), client_config),
658            (MAIL_CONFIG_KEY.to_string(), mail_config),
659        ])),
660        type_: Some("Opaque".to_string()),
661        ..Default::default()
662    })
663}
664
665// Follow Kanidm's Docker Hub release convention: server:<tag> -> tools:<tag>.
666// Image digests identify individual artifacts and must never be carried from
667// the server image into the separate tools image. The explicit mailSender.image
668// always takes precedence over this default.
669fn default_mail_sender_image(server_image: &str) -> Result<String> {
670    let tag = match kaniop_k8s_util::resources::get_image_tag(server_image) {
671        Some(tag) => tag,
672        None if !server_image.contains('@') => "latest".to_string(),
673        None => {
674            return Err(Error::MissingData(
675                "Cannot infer a mail sender image tag from the Kanidm server image; set spec.mailSender.image explicitly".to_string(),
676            ));
677        }
678    };
679
680    Ok(format!("kanidm/tools:{tag}"))
681}
682
683fn create_deployment(
684    kanidm: &Kanidm,
685    name: &str,
686    spec: &MailSenderSpec,
687    config_secret_name: &str,
688    ca_hash: Option<&str>,
689) -> Result<Deployment> {
690    debug!(name, "creating deployment");
691
692    let namespace = kanidm.namespace().unwrap();
693    let image = match &spec.image {
694        Some(image) => image.clone(),
695        None => default_mail_sender_image(&kanidm.spec.image)?,
696    };
697
698    let extended_labels = generate_extended_mail_sender_labels(kanidm);
699
700    let mut container = Container {
701        name: MAIL_SENDER_COMPONENT.to_string(),
702        image: Some(image),
703        image_pull_policy: kanidm.spec.image_pull_policy.clone(),
704        env: spec.log_level.map(|level| {
705            vec![EnvVar {
706                name: "RUST_LOG".to_string(),
707                value: Some(level.as_str().to_string()),
708                ..Default::default()
709            }]
710        }),
711        command: Some(vec![
712            "/sbin/kanidm-mail-sender".to_string(),
713            "-c".to_string(),
714            format!("/data/config/{CLIENT_CONFIG_KEY}"),
715            "-m".to_string(),
716            format!("/data/config/{MAIL_CONFIG_KEY}"),
717        ]),
718        resources: spec.resources.clone(),
719        volume_mounts: Some(vec![VolumeMount {
720            name: "config".to_string(),
721            mount_path: "/data/config".to_string(),
722            read_only: Some(true),
723            ..Default::default()
724        }]),
725        ..Default::default()
726    };
727
728    if spec.ca_bundle_ref.is_some() {
729        container
730            .volume_mounts
731            .get_or_insert_with(Vec::new)
732            .push(build_ca_bundle_volume_mount());
733    }
734
735    let mut pod_spec = PodSpec {
736        containers: vec![container],
737        security_context: Some(kanidm.spec.security_context.clone().unwrap_or_else(|| {
738            PodSecurityContext {
739                run_as_non_root: Some(true),
740                run_as_user: Some(65534),
741                ..Default::default()
742            }
743        })),
744        volumes: Some(vec![Volume {
745            name: "config".to_string(),
746            secret: Some(SecretVolumeSource {
747                secret_name: Some(config_secret_name.to_string()),
748                items: Some(vec![
749                    KeyToPath {
750                        key: CLIENT_CONFIG_KEY.to_string(),
751                        path: CLIENT_CONFIG_KEY.to_string(),
752                        ..Default::default()
753                    },
754                    KeyToPath {
755                        key: MAIL_CONFIG_KEY.to_string(),
756                        path: MAIL_CONFIG_KEY.to_string(),
757                        ..Default::default()
758                    },
759                ]),
760                ..Default::default()
761            }),
762            ..Default::default()
763        }]),
764        node_selector: spec.node_selector.clone(),
765        affinity: spec.affinity.clone(),
766        tolerations: spec.tolerations.clone(),
767        automount_service_account_token: Some(false),
768        ..Default::default()
769    };
770
771    if let Some(ca_bundle_ref) = &spec.ca_bundle_ref {
772        pod_spec
773            .volumes
774            .get_or_insert_with(Vec::new)
775            .push(build_ca_bundle_volume(ca_bundle_ref));
776    }
777
778    let pod_template = PodTemplateSpec {
779        metadata: Some(k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta {
780            labels: Some(extended_labels.clone()),
781            annotations: ca_hash.map(|hash| {
782                BTreeMap::from([(MAIL_SENDER_CA_HASH_ANNOTATION.to_string(), hash.to_string())])
783            }),
784            ..Default::default()
785        }),
786        spec: Some(pod_spec),
787    };
788
789    Ok(Deployment {
790        metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta {
791            name: Some(name.to_string()),
792            namespace: Some(namespace),
793            owner_references: kanidm.controller_owner_ref(&()).map(|oref| vec![oref]),
794            labels: Some(extended_labels.clone()),
795            ..Default::default()
796        },
797        spec: Some(DeploymentSpec {
798            replicas: Some(1),
799            selector: k8s_openapi::apimachinery::pkg::apis::meta::v1::LabelSelector {
800                match_labels: Some(extended_labels),
801                ..Default::default()
802            },
803            template: pod_template,
804            strategy: Some(DeploymentStrategy {
805                type_: Some("Recreate".to_string()),
806                ..Default::default()
807            }),
808            ..Default::default()
809        }),
810        ..Default::default()
811    })
812}
813
814struct SmtpCredentials {
815    username: String,
816    password: String,
817}
818
819async fn read_smtp_credentials(
820    ctx: &Context,
821    spec: &MailSenderSpec,
822    namespace: &str,
823) -> Result<Option<SmtpCredentials>> {
824    let Some(credentials_ref) = spec.credentials_secret.as_ref() else {
825        return Ok(None);
826    };
827    let secret_api: Api<Secret> = Api::namespaced(ctx.kaniop_ctx.client.clone(), namespace);
828    let secret = secret_api.get(&credentials_ref.name).await.map_err(|e| {
829        Error::kube_error(
830            "get",
831            "SMTP credentials secret",
832            namespace,
833            &credentials_ref.name,
834            e,
835        )
836    })?;
837
838    let username_key = &credentials_ref.username_key;
839    let password_key = &credentials_ref.password_key;
840
841    let get_string = |key: &str| -> Result<String> {
842        secret
843            .string_data
844            .as_ref()
845            .and_then(|d| d.get(key).cloned())
846            .or_else(|| {
847                secret
848                    .data
849                    .as_ref()
850                    .and_then(|d| d.get(key))
851                    .map(|v| String::from_utf8_lossy(&v.0).to_string())
852            })
853            .ok_or_else(|| {
854                Error::MissingData(format!(
855                    "SMTP credentials secret {} missing key {}",
856                    credentials_ref.name, key
857                ))
858            })
859    };
860
861    Ok(Some(SmtpCredentials {
862        username: get_string(username_key)?,
863        password: get_string(password_key)?,
864    }))
865}
866
867pub async fn cleanup_mail_sender_resources(kanidm: &Kanidm, ctx: &Context) -> Result<bool> {
868    let namespace = kanidm.namespace().unwrap();
869    let kanidm_name = kanidm.name_any();
870    let mut changed = false;
871
872    let deployment_name = mail_sender_deployment_name(&kanidm_name);
873    let config_secret_name = mail_sender_config_map_name(&kanidm_name);
874
875    let deployment_api: Api<Deployment> =
876        Api::namespaced(ctx.kaniop_ctx.client.clone(), &namespace);
877    let secret_api: Api<k8s_openapi::api::core::v1::Secret> =
878        Api::namespaced(ctx.kaniop_ctx.client.clone(), &namespace);
879
880    let dp = DeleteParams::default();
881
882    match deployment_api.delete(&deployment_name, &dp).await {
883        Ok(_) => {
884            changed = true;
885        }
886        Err(kube::Error::Api(e)) if e.code == 404 => {
887            debug!(deployment_name, "mail sender deployment already absent");
888        }
889        Err(e) => {
890            return Err(Error::kube_error(
891                "delete",
892                "deployment",
893                &namespace,
894                &deployment_name,
895                e,
896            ));
897        }
898    }
899
900    match secret_api.delete(&config_secret_name, &dp).await {
901        Ok(_) => {
902            changed = true;
903        }
904        Err(kube::Error::Api(e)) if e.code == 404 => {
905            debug!(
906                config_secret_name,
907                "mail sender config secret already absent"
908            );
909        }
910        Err(e) => {
911            return Err(Error::kube_error(
912                "delete",
913                "secret",
914                &namespace,
915                &config_secret_name,
916                e,
917            ));
918        }
919    }
920
921    Ok(changed)
922}
923
924pub async fn cleanup_mail_sender_in_kanidm(
925    kanidm_client: &KanidmClient,
926    kanidm_name: &str,
927    metrics: &crate::metrics::ControllerMetrics,
928) -> Result<bool> {
929    let sa_name = mail_sender_service_account_name(kanidm_name);
930    let mut changed = false;
931
932    debug!(sa_name, "removing mail sender from message_senders group");
933    let start = tokio::time::Instant::now();
934    let remove_result = kanidm_client
935        .idm_group_remove_members(MESSAGE_SENDERS_GROUP, &[&sa_name])
936        .await;
937    match remove_result {
938        Ok(()) => {
939            metrics.record_kanidm_sdk_outcome(
940                KANIDM_RESOURCE_MAIL_SENDER,
941                KANIDM_OP_REMOVE_MEMBERS,
942                KANIDM_OUTCOME_CHANGED,
943                start.elapsed(),
944            );
945            changed = true;
946        }
947        Err(e) if is_not_found_error(&e) || is_not_a_member_error(&e) => {
948            debug!(sa_name, "mail sender group membership already absent");
949            metrics.record_kanidm_sdk_outcome(
950                KANIDM_RESOURCE_MAIL_SENDER,
951                KANIDM_OP_REMOVE_MEMBERS,
952                KANIDM_OUTCOME_UNCHANGED,
953                start.elapsed(),
954            );
955        }
956        Err(e) => {
957            metrics.record_kanidm_sdk_outcome(
958                KANIDM_RESOURCE_MAIL_SENDER,
959                KANIDM_OP_REMOVE_MEMBERS,
960                KANIDM_OUTCOME_ERROR,
961                start.elapsed(),
962            );
963            return Err(Error::KanidmClientError(
964                format!("failed to remove {sa_name} from {MESSAGE_SENDERS_GROUP}"),
965                Box::new(e),
966            ));
967        }
968    }
969
970    debug!(sa_name, "deleting mail sender service account");
971    let start = tokio::time::Instant::now();
972    let delete_result = kanidm_client.idm_service_account_delete(&sa_name).await;
973    match delete_result {
974        Ok(()) => {
975            metrics.record_kanidm_sdk_outcome(
976                KANIDM_RESOURCE_MAIL_SENDER,
977                KANIDM_OP_DELETE,
978                KANIDM_OUTCOME_CHANGED,
979                start.elapsed(),
980            );
981            changed = true;
982        }
983        Err(e) if is_not_found_error(&e) => {
984            debug!(sa_name, "mail sender service account already absent");
985            metrics.record_kanidm_sdk_outcome(
986                KANIDM_RESOURCE_MAIL_SENDER,
987                KANIDM_OP_DELETE,
988                KANIDM_OUTCOME_UNCHANGED,
989                start.elapsed(),
990            );
991        }
992        Err(e) => {
993            metrics.record_kanidm_sdk_outcome(
994                KANIDM_RESOURCE_MAIL_SENDER,
995                KANIDM_OP_DELETE,
996                KANIDM_OUTCOME_ERROR,
997                start.elapsed(),
998            );
999            return Err(Error::KanidmClientError(
1000                format!("failed to delete service account {sa_name}"),
1001                Box::new(e),
1002            ));
1003        }
1004    }
1005
1006    Ok(changed)
1007}
1008
1009fn is_already_exists_error(e: &kanidm_client::ClientError) -> bool {
1010    match e {
1011        kanidm_client::ClientError::Http(status, _, body) => {
1012            status.as_u16() == 409
1013                || body.contains("already exists")
1014                || body.contains("conflicting_with")
1015                || body.contains("AttributeUniqueness")
1016        }
1017        _ => false,
1018    }
1019}
1020
1021fn is_not_found_error(e: &kanidm_client::ClientError) -> bool {
1022    match e {
1023        ClientError::Http(status, operation_error, body) => {
1024            status.as_u16() == 404
1025                || operation_error == &Some(OperationError::NoMatchingEntries)
1026                || body.contains("NoMatchingEntries")
1027                || body.contains("not found")
1028                || body.contains("does not exist")
1029        }
1030        _ => false,
1031    }
1032}
1033
1034fn is_not_a_member_error(e: &kanidm_client::ClientError) -> bool {
1035    match e {
1036        ClientError::Http(_, _, body) => body.contains("not a member"),
1037        _ => false,
1038    }
1039}
1040
1041fn toml_basic_string(value: &str) -> String {
1042    let mut output = String::with_capacity(value.len() + 2);
1043    output.push('"');
1044    for c in value.chars() {
1045        match c {
1046            '\u{08}' => output.push_str("\\b"),
1047            '\t' => output.push_str("\\t"),
1048            '\n' => output.push_str("\\n"),
1049            '\u{0c}' => output.push_str("\\f"),
1050            '\r' => output.push_str("\\r"),
1051            '"' => output.push_str("\\\""),
1052            '\\' => output.push_str("\\\\"),
1053            c if c.is_control() => {
1054                let code = c as u32;
1055                if code <= 0xffff {
1056                    output.push_str(&format!("\\u{code:04X}"));
1057                } else {
1058                    output.push_str(&format!("\\U{code:08X}"));
1059                }
1060            }
1061            c => output.push(c),
1062        }
1063    }
1064    output.push('"');
1065    output
1066}
1067
1068fn generate_mail_sender_labels(kanidm: &Kanidm) -> BTreeMap<String, String> {
1069    BTreeMap::from([
1070        (NAME_LABEL.to_string(), "kanidm".to_string()),
1071        (
1072            MANAGED_BY_LABEL.to_string(),
1073            format!("kaniop-{}", super::super::controller::CONTROLLER_ID),
1074        ),
1075        (INSTANCE_LABEL.to_string(), kanidm.name_any()),
1076        (CLUSTER_LABEL.to_string(), kanidm.name_any()),
1077    ])
1078}
1079
1080fn generate_extended_mail_sender_labels(kanidm: &Kanidm) -> BTreeMap<String, String> {
1081    generate_mail_sender_labels(kanidm)
1082        .into_iter()
1083        .chain([
1084            (MAIL_SENDER_LABEL.to_string(), kanidm.name_any()),
1085            (NAME_LABEL.to_string(), MAIL_SENDER_COMPONENT.to_string()),
1086        ])
1087        .collect()
1088}
1089
1090#[cfg(test)]
1091mod tests {
1092    use super::{
1093        create_deployment, default_mail_sender_image, group_contains_member, toml_basic_string,
1094    };
1095    use crate::kanidm::crd::{CaBundleRef, Kanidm, MailSenderLogLevel, MailSenderSpec};
1096    use k8s_openapi::api::core::v1::ConfigMap;
1097    use kanidm_client::KanidmClientBuilder;
1098    use openssl::asn1::Asn1Time;
1099    use openssl::bn::BigNum;
1100    use openssl::hash::MessageDigest;
1101    use openssl::pkey::{PKey, Private};
1102    use openssl::rsa::Rsa;
1103    use openssl::ssl::{SslAcceptor, SslMethod};
1104    use openssl::x509::extension::{BasicConstraints, KeyUsage, SubjectAlternativeName};
1105    use openssl::x509::{X509, X509NameBuilder};
1106    use serde_json::json;
1107    use std::io::{Read, Write};
1108    use std::net::TcpListener;
1109
1110    #[test]
1111    fn smtp_auth_is_optional_in_generated_mail_sender_config() {
1112        let kanidm: Kanidm = serde_json::from_value(json!({
1113            "apiVersion": "kaniop.rs/v1beta1",
1114            "kind": "Kanidm",
1115            "metadata": {"name": "idm", "namespace": "default"},
1116            "spec": {
1117                "domain": "idm.example.com",
1118                "replicaGroups": [{"name": "default", "replicas": 1}]
1119            }
1120        }))
1121        .unwrap();
1122        let spec: MailSenderSpec = serde_json::from_value(json!({
1123            "relay": "smtp://relay.example.com:587",
1124            "fromAddress": "kanidm@example.com"
1125        }))
1126        .unwrap();
1127        assert!(spec.credentials_secret.is_none());
1128        assert!(
1129            serde_json::to_value(&spec)
1130                .unwrap()
1131                .get("credentialsSecret")
1132                .is_none()
1133        );
1134
1135        let render = |credentials: Option<&super::SmtpCredentials>| {
1136            super::create_config_secret(
1137                &kanidm,
1138                "idm-mail-sender-config",
1139                &spec,
1140                "api-token",
1141                credentials,
1142            )
1143            .unwrap()
1144            .string_data
1145            .unwrap()
1146            .remove(super::MAIL_CONFIG_KEY)
1147            .unwrap()
1148        };
1149        let without_auth = render(None);
1150        assert!(without_auth.contains("mail_relay = \"smtp://relay.example.com:587\""));
1151        assert!(!without_auth.contains("mail_username ="));
1152        assert!(!without_auth.contains("mail_password ="));
1153        assert!(without_auth.contains("mail_connect_timeout_seconds = 15"));
1154
1155        let credentials = super::SmtpCredentials {
1156            username: "smtp-user".to_string(),
1157            password: "smtp-password".to_string(),
1158        };
1159        let with_auth = render(Some(&credentials));
1160        assert!(with_auth.contains("mail_username = \"smtp-user\""));
1161        assert!(with_auth.contains("mail_password = \"smtp-password\""));
1162
1163        let legacy_spec: MailSenderSpec = serde_json::from_value(json!({
1164            "relay": "smtps://smtp.example.com",
1165            "credentialsSecret": {"name": "smtp-credentials"},
1166            "fromAddress": "kanidm@example.com"
1167        }))
1168        .unwrap();
1169        assert_eq!(
1170            legacy_spec.credentials_secret.unwrap().name,
1171            "smtp-credentials"
1172        );
1173    }
1174
1175    fn tls_test_certificates() -> (Vec<u8>, Vec<u8>, Vec<u8>) {
1176        let ca_key = PKey::from_rsa(Rsa::generate(2048).unwrap()).unwrap();
1177        let mut ca_name = X509NameBuilder::new().unwrap();
1178        ca_name
1179            .append_entry_by_text("CN", "Kaniop Test CA")
1180            .unwrap();
1181        let ca_name = ca_name.build();
1182        let mut ca_builder = X509::builder().unwrap();
1183        ca_builder.set_version(2).unwrap();
1184        let serial = BigNum::from_u32(1).unwrap().to_asn1_integer().unwrap();
1185        ca_builder.set_serial_number(&serial).unwrap();
1186        ca_builder.set_subject_name(&ca_name).unwrap();
1187        ca_builder.set_issuer_name(&ca_name).unwrap();
1188        ca_builder.set_pubkey(&ca_key).unwrap();
1189        ca_builder
1190            .set_not_before(&Asn1Time::days_from_now(0).unwrap())
1191            .unwrap();
1192        ca_builder
1193            .set_not_after(&Asn1Time::days_from_now(2).unwrap())
1194            .unwrap();
1195        ca_builder
1196            .append_extension(BasicConstraints::new().critical().ca().build().unwrap())
1197            .unwrap();
1198        ca_builder
1199            .append_extension(
1200                KeyUsage::new()
1201                    .critical()
1202                    .key_cert_sign()
1203                    .crl_sign()
1204                    .build()
1205                    .unwrap(),
1206            )
1207            .unwrap();
1208        ca_builder.sign(&ca_key, MessageDigest::sha256()).unwrap();
1209        let ca = ca_builder.build();
1210
1211        let leaf_key = PKey::from_rsa(Rsa::generate(2048).unwrap()).unwrap();
1212        let mut leaf_name = X509NameBuilder::new().unwrap();
1213        leaf_name.append_entry_by_text("CN", "localhost").unwrap();
1214        let leaf_name = leaf_name.build();
1215        let mut leaf_builder = X509::builder().unwrap();
1216        leaf_builder.set_version(2).unwrap();
1217        let serial = BigNum::from_u32(2).unwrap().to_asn1_integer().unwrap();
1218        leaf_builder.set_serial_number(&serial).unwrap();
1219        leaf_builder.set_subject_name(&leaf_name).unwrap();
1220        leaf_builder.set_issuer_name(ca.subject_name()).unwrap();
1221        leaf_builder.set_pubkey(&leaf_key).unwrap();
1222        leaf_builder
1223            .set_not_before(&Asn1Time::days_from_now(0).unwrap())
1224            .unwrap();
1225        leaf_builder
1226            .set_not_after(&Asn1Time::days_from_now(2).unwrap())
1227            .unwrap();
1228        leaf_builder
1229            .append_extension(BasicConstraints::new().critical().build().unwrap())
1230            .unwrap();
1231        leaf_builder
1232            .append_extension(
1233                KeyUsage::new()
1234                    .critical()
1235                    .digital_signature()
1236                    .key_encipherment()
1237                    .build()
1238                    .unwrap(),
1239            )
1240            .unwrap();
1241        let san = SubjectAlternativeName::new()
1242            .dns("localhost")
1243            .build(&leaf_builder.x509v3_context(Some(&ca), None))
1244            .unwrap();
1245        leaf_builder.append_extension(san).unwrap();
1246        leaf_builder.sign(&ca_key, MessageDigest::sha256()).unwrap();
1247        (
1248            ca.to_pem().unwrap(),
1249            leaf_builder.build().to_pem().unwrap(),
1250            leaf_key.private_key_to_pem_pkcs8().unwrap(),
1251        )
1252    }
1253
1254    #[test]
1255    fn ca_rotation_changes_pod_template_hash_only_for_selected_key() {
1256        let (ca_pem, _, _) = tls_test_certificates();
1257        let (other_ca_pem, _, _) = tls_test_certificates();
1258        let ca_ref = CaBundleRef {
1259            name: "private-pki".into(),
1260            key: "ca.crt".into(),
1261        };
1262        let mut cm = ConfigMap {
1263            data: Some(
1264                [
1265                    ("ca.crt".to_string(), String::from_utf8(ca_pem).unwrap()),
1266                    ("other".to_string(), "original".to_string()),
1267                ]
1268                .into(),
1269            ),
1270            ..Default::default()
1271        };
1272        let first_hash = super::ca_bundle_digest(super::ca_bundle_bytes(&ca_ref, &cm).unwrap());
1273        cm.data
1274            .as_mut()
1275            .unwrap()
1276            .insert("other".into(), "updated".into());
1277        let same_hash = super::ca_bundle_digest(super::ca_bundle_bytes(&ca_ref, &cm).unwrap());
1278        assert_eq!(first_hash, same_hash);
1279        cm.data
1280            .as_mut()
1281            .unwrap()
1282            .insert("ca.crt".into(), String::from_utf8(other_ca_pem).unwrap());
1283        let new_hash = super::ca_bundle_digest(super::ca_bundle_bytes(&ca_ref, &cm).unwrap());
1284        assert_ne!(first_hash, new_hash);
1285
1286        let kanidm: Kanidm = serde_json::from_value(json!({
1287            "apiVersion": "kaniop.rs/v1beta1", "kind": "Kanidm",
1288            "metadata": {"name": "idm", "namespace": "default"},
1289            "spec": {"domain": "idm.example.com",
1290                     "replicaGroups": [{"name": "default", "replicas": 1}]}
1291        }))
1292        .unwrap();
1293        let spec: MailSenderSpec = serde_json::from_value(json!({
1294            "relay": "smtps://smtp.example.com",
1295            "credentialsSecret": {"name": "smtp-credentials"},
1296            "fromAddress": "kanidm@example.com",
1297            "caBundleRef": {"name": "private-pki", "key": "ca.crt"}
1298        }))
1299        .unwrap();
1300        let template_hash = |hash: &str| {
1301            let deployment = create_deployment(
1302                &kanidm,
1303                "idm-mail-sender",
1304                &spec,
1305                "idm-mail-sender-config",
1306                Some(hash),
1307            )
1308            .unwrap();
1309            deployment
1310                .spec
1311                .unwrap()
1312                .template
1313                .metadata
1314                .unwrap()
1315                .annotations
1316                .unwrap()[super::MAIL_SENDER_CA_HASH_ANNOTATION]
1317                .clone()
1318        };
1319        assert_eq!(template_hash(&first_hash), template_hash(&same_hash));
1320        assert_ne!(template_hash(&first_hash), template_hash(&new_hash));
1321    }
1322
1323    #[test]
1324    fn invalid_ca_reference_and_missing_key_are_rejected() {
1325        for (name, key) in [("", "ca.crt"), ("private-pki", ""), ("  ", "  ")] {
1326            assert!(
1327                super::validate_ca_bundle_ref(&CaBundleRef {
1328                    name: name.to_string(),
1329                    key: key.to_string(),
1330                })
1331                .is_err()
1332            );
1333        }
1334        let ca_ref = CaBundleRef {
1335            name: "private-pki".into(),
1336            key: "ca.crt".into(),
1337        };
1338        let empty = ConfigMap::default();
1339        assert!(super::ca_bundle_bytes(&ca_ref, &empty).is_err());
1340        let invalid = ConfigMap {
1341            data: Some([("ca.crt".into(), "not a PEM".into())].into()),
1342            ..Default::default()
1343        };
1344        assert!(super::ca_bundle_bytes(&ca_ref, &invalid).is_err());
1345    }
1346
1347    #[tokio::test]
1348    async fn private_ca_allows_verified_https_from_generated_client_config() {
1349        let (ca_pem, server_cert, server_key) = tls_test_certificates();
1350        let listener = TcpListener::bind("127.0.0.1:0").unwrap();
1351        let url = format!(
1352            "https://localhost:{}",
1353            listener.local_addr().unwrap().port()
1354        );
1355        let server =
1356            std::thread::spawn(move || {
1357                let key = PKey::<Private>::private_key_from_pem(&server_key).unwrap();
1358                let cert = X509::from_pem(&server_cert).unwrap();
1359                let mut acceptor = SslAcceptor::mozilla_intermediate(SslMethod::tls()).unwrap();
1360                acceptor.set_private_key(&key).unwrap();
1361                acceptor.set_certificate(&cert).unwrap();
1362                acceptor.check_private_key().unwrap();
1363                let acceptor = acceptor.build();
1364                for _ in 0..2 {
1365                    let (stream, _) = listener.accept().unwrap();
1366                    stream
1367                        .set_read_timeout(Some(std::time::Duration::from_secs(5)))
1368                        .unwrap();
1369                    if let Ok(mut connection) = acceptor.accept(stream) {
1370                        let mut request = [0u8; 2048];
1371                        let _ = connection.read(&mut request);
1372                        connection.write_all(
1373                        b"HTTP/1.1 200 OK\r\nContent-Length: 2\r\nConnection: close\r\n\r\nOK",
1374                    ).unwrap();
1375                    }
1376                }
1377            });
1378
1379        let tmp = tempfile::tempdir().unwrap();
1380        let ca_file = tmp.path().join("ca.pem");
1381        std::fs::write(&ca_file, ca_pem).unwrap();
1382        let config_file = tmp.path().join("client.toml");
1383        let mut kanidm: Kanidm = serde_json::from_value(json!({
1384            "apiVersion": "kaniop.rs/v1beta1", "kind": "Kanidm",
1385            "metadata": {"name": "idm", "namespace": "default"},
1386            "spec": {"domain": "idm.example.com",
1387                     "replicaGroups": [{"name": "default", "replicas": 1}]}
1388        }))
1389        .unwrap();
1390        kanidm.spec.origin = Some(url.clone());
1391        let mut spec: MailSenderSpec = serde_json::from_value(json!({
1392            "relay": "smtps://smtp.example.com",
1393            "credentialsSecret": {"name": "smtp-credentials"},
1394            "fromAddress": "kanidm@example.com"
1395        }))
1396        .unwrap();
1397        let credentials = super::SmtpCredentials {
1398            username: "smtp-user".into(),
1399            password: "smtp-password".into(),
1400        };
1401        let generated = |spec: &MailSenderSpec| {
1402            super::create_config_secret(
1403                &kanidm,
1404                "idm-mail-sender-config",
1405                spec,
1406                "token",
1407                Some(&credentials),
1408            )
1409            .unwrap()
1410            .string_data
1411            .unwrap()[super::CLIENT_CONFIG_KEY]
1412                .clone()
1413        };
1414        std::fs::write(&config_file, generated(&spec)).unwrap();
1415        let untrusted = KanidmClientBuilder::new()
1416            .no_proxy()
1417            .read_options_from_optional_config(&config_file)
1418            .unwrap()
1419            .build()
1420            .unwrap();
1421        assert!(
1422            untrusted.client().get(&url).send().await.is_err(),
1423            "untrusted CA must fail verification"
1424        );
1425
1426        spec.ca_bundle_ref = Some(CaBundleRef {
1427            name: "private-pki".into(),
1428            key: "ca.crt".into(),
1429        });
1430        // The production path is a projected ConfigMap. Replace only that path
1431        // with an equivalent test-mounted PEM file.
1432        let config = generated(&spec).replace(
1433            kaniop_backup_core::auth::CA_BUNDLE_MOUNT_PATH,
1434            ca_file.to_str().unwrap(),
1435        );
1436        assert!(config.contains("ca_path = "));
1437        std::fs::write(&config_file, config).unwrap();
1438        let trusted = KanidmClientBuilder::new()
1439            .no_proxy()
1440            .read_options_from_optional_config(&config_file)
1441            .unwrap()
1442            .build()
1443            .unwrap();
1444        let response = trusted.client().get(&url).send().await.unwrap();
1445        assert!(response.status().is_success());
1446        server.join().unwrap();
1447    }
1448
1449    #[test]
1450    fn custom_ca_bundle_configures_mail_sender_client_and_pod() {
1451        let kanidm: Kanidm = serde_json::from_value(json!({
1452            "apiVersion": "kaniop.rs/v1beta1",
1453            "kind": "Kanidm",
1454            "metadata": {"name": "idm", "namespace": "default"},
1455            "spec": {
1456                "domain": "idm.example.com",
1457                "replicaGroups": [{"name": "default", "replicas": 1}]
1458            }
1459        }))
1460        .unwrap();
1461        let mut spec: MailSenderSpec = serde_json::from_value(json!({
1462            "relay": "smtps://smtp.example.com",
1463            "credentialsSecret": {"name": "smtp-credentials"},
1464            "fromAddress": "kanidm@example.com",
1465            "caBundleRef": {"name": "private-pki", "key": "ca.crt"}
1466        }))
1467        .unwrap();
1468        let credentials = super::SmtpCredentials {
1469            username: "smtp-user".to_string(),
1470            password: "smtp-password".to_string(),
1471        };
1472
1473        // Use Kanidm's native client trust setting, without disabling TLS verification.
1474        let secret = super::create_config_secret(
1475            &kanidm,
1476            "idm-mail-sender-config",
1477            &spec,
1478            "token",
1479            Some(&credentials),
1480        )
1481        .unwrap();
1482        let config = secret.string_data.unwrap();
1483        assert_eq!(
1484            config[super::CLIENT_CONFIG_KEY],
1485            format!(
1486                "uri = \"https://idm.example.com\"\nca_path = \"{}\"",
1487                kaniop_backup_core::auth::CA_BUNDLE_MOUNT_PATH
1488            )
1489        );
1490        let deployment = create_deployment(
1491            &kanidm,
1492            "idm-mail-sender",
1493            &spec,
1494            "idm-mail-sender-config",
1495            None,
1496        )
1497        .unwrap();
1498        let pod = deployment.spec.unwrap().template.spec.unwrap();
1499        let volume = pod
1500            .volumes
1501            .as_ref()
1502            .unwrap()
1503            .iter()
1504            .find(|volume| volume.name == kaniop_backup_core::auth::CA_BUNDLE_VOLUME_NAME)
1505            .unwrap();
1506        let cm = volume.config_map.as_ref().unwrap();
1507        assert_eq!(cm.name, "private-pki");
1508        assert_eq!(cm.items.as_ref().unwrap()[0].key, "ca.crt");
1509        assert_eq!(
1510            cm.items.as_ref().unwrap()[0].path,
1511            kaniop_backup_core::auth::CA_BUNDLE_FILE_NAME
1512        );
1513        let mount = pod.containers[0]
1514            .volume_mounts
1515            .as_ref()
1516            .unwrap()
1517            .iter()
1518            .find(|mount| mount.name == kaniop_backup_core::auth::CA_BUNDLE_VOLUME_NAME)
1519            .unwrap();
1520        assert_eq!(
1521            mount.mount_path,
1522            kaniop_backup_core::auth::CA_BUNDLE_MOUNT_DIR
1523        );
1524        assert_eq!(mount.read_only, Some(true));
1525        assert_eq!(pod.volumes.as_ref().unwrap().len(), 2);
1526
1527        // Removing the reference restores the previous manifest and client configuration.
1528        spec.ca_bundle_ref = None;
1529        let secret = super::create_config_secret(
1530            &kanidm,
1531            "idm-mail-sender-config",
1532            &spec,
1533            "token",
1534            Some(&credentials),
1535        )
1536        .unwrap();
1537        assert_eq!(
1538            secret.string_data.unwrap()[super::CLIENT_CONFIG_KEY],
1539            "uri = \"https://idm.example.com\""
1540        );
1541        let deployment = create_deployment(
1542            &kanidm,
1543            "idm-mail-sender",
1544            &spec,
1545            "idm-mail-sender-config",
1546            None,
1547        )
1548        .unwrap();
1549        let pod = deployment.spec.unwrap().template.spec.unwrap();
1550        assert_eq!(pod.volumes.as_ref().unwrap().len(), 1);
1551        assert_eq!(pod.containers[0].volume_mounts.as_ref().unwrap().len(), 1);
1552    }
1553
1554    #[test]
1555    fn ca_bundle_ref_requires_a_configmap_name_and_key() {
1556        assert!(
1557            serde_json::from_value::<MailSenderSpec>(json!({
1558                "relay": "smtps://smtp.example.com",
1559                "credentialsSecret": {"name": "smtp-credentials"},
1560                "fromAddress": "kanidm@example.com",
1561                "caBundleRef": {"name": "private-pki"}
1562            }))
1563            .is_err()
1564        );
1565    }
1566
1567    #[test]
1568    fn mail_sender_log_level_sets_rust_log_only_when_configured() {
1569        let kanidm: Kanidm = serde_json::from_value(json!({
1570            "apiVersion": "kaniop.rs/v1beta1",
1571            "kind": "Kanidm",
1572            "metadata": {"name": "idm", "namespace": "default"},
1573            "spec": {
1574                "domain": "idm.example.com",
1575                "replicaGroups": [{"name": "default", "replicas": 1}]
1576            }
1577        }))
1578        .unwrap();
1579        let mut spec: MailSenderSpec = serde_json::from_value(json!({
1580            "relay": "smtps://smtp.example.com",
1581            "fromAddress": "kanidm@example.com"
1582        }))
1583        .unwrap();
1584
1585        let render = |spec: &MailSenderSpec| {
1586            create_deployment(&kanidm, "idm-mail-sender", spec, "idm-config", None)
1587                .unwrap()
1588                .spec
1589                .unwrap()
1590                .template
1591                .spec
1592                .unwrap()
1593                .containers
1594                .remove(0)
1595        };
1596
1597        assert!(spec.log_level.is_none());
1598        assert!(render(&spec).env.is_none());
1599        assert!(
1600            serde_json::to_value(&spec)
1601                .unwrap()
1602                .get("logLevel")
1603                .is_none()
1604        );
1605
1606        for (level, expected) in [
1607            (MailSenderLogLevel::Trace, "trace"),
1608            (MailSenderLogLevel::Debug, "debug"),
1609            (MailSenderLogLevel::Info, "info"),
1610            (MailSenderLogLevel::Warn, "warn"),
1611            (MailSenderLogLevel::Error, "error"),
1612            (MailSenderLogLevel::Off, "off"),
1613        ] {
1614            spec.log_level = Some(level);
1615            let env = render(&spec).env.unwrap();
1616            assert_eq!(env.len(), 1);
1617            assert_eq!(env[0].name, "RUST_LOG");
1618            assert_eq!(env[0].value.as_deref(), Some(expected));
1619            assert_eq!(serde_json::to_value(&spec).unwrap()["logLevel"], expected);
1620        }
1621
1622        spec.log_level = None;
1623        assert!(render(&spec).env.is_none());
1624        assert!(
1625            serde_json::from_value::<MailSenderSpec>(json!({
1626                "relay": "smtps://smtp.example.com",
1627                "fromAddress": "kanidm@example.com",
1628                "logLevel": "verbose"
1629            }))
1630            .is_err()
1631        );
1632    }
1633
1634    #[test]
1635    fn digest_pinned_server_image_creates_pullable_mail_sender_deployment() {
1636        // Use the exact tagged-and-digest-pinned input shape from issue #1110.
1637        let kanidm: Kanidm = serde_json::from_value(json!({
1638            "apiVersion": "kaniop.rs/v1beta1",
1639            "kind": "Kanidm",
1640            "metadata": {"name": "idm", "namespace": "default"},
1641            "spec": {
1642                "domain": "idm.example.com",
1643                "image": "kanidm/server:1.11.2@sha256:deadbeef",
1644                "replicaGroups": [{"name": "default", "replicas": 1}]
1645            }
1646        }))
1647        .unwrap();
1648        let mail_sender_spec: MailSenderSpec = serde_json::from_value(json!({
1649            "relay": "smtps://smtp.example.com",
1650            "credentialsSecret": {"name": "smtp-credentials"},
1651            "fromAddress": "kanidm@example.com"
1652        }))
1653        .unwrap();
1654
1655        let deployment = create_deployment(
1656            &kanidm,
1657            "idm-mail-sender",
1658            &mail_sender_spec,
1659            "idm-mail-sender-config",
1660            None,
1661        )
1662        .unwrap();
1663
1664        let image = deployment.spec.unwrap().template.spec.unwrap().containers[0]
1665            .image
1666            .clone();
1667        assert_eq!(image.as_deref(), Some("kanidm/tools:1.11.2"));
1668        assert!(!image.unwrap().contains("@sha256:"));
1669
1670        // An override is an exact image reference, including its own digest.
1671        // It must not be parsed, rewritten or constrained by the server image.
1672        let override_image = "mirror.example.org/custom/mail-sender:custom@sha256:abcdef";
1673        let mut overridden = mail_sender_spec;
1674        overridden.image = Some(override_image.to_string());
1675        let deployment = create_deployment(
1676            &kanidm,
1677            "idm-mail-sender",
1678            &overridden,
1679            "idm-mail-sender-config",
1680            None,
1681        )
1682        .unwrap();
1683        assert_eq!(
1684            deployment.spec.unwrap().template.spec.unwrap().containers[0]
1685                .image
1686                .as_deref(),
1687            Some(override_image),
1688        );
1689
1690        // Even a digest-only server image can be used with an explicit override.
1691        let mut digest_only_server = kanidm;
1692        digest_only_server.spec.image = "kanidm/server@sha256:deadbeef".to_string();
1693        let deployment = create_deployment(
1694            &digest_only_server,
1695            "idm-mail-sender",
1696            &overridden,
1697            "idm-mail-sender-config",
1698            None,
1699        )
1700        .unwrap();
1701        assert_eq!(
1702            deployment.spec.unwrap().template.spec.unwrap().containers[0]
1703                .image
1704                .as_deref(),
1705            Some(override_image),
1706        );
1707    }
1708
1709    #[test]
1710    fn default_mail_sender_image_uses_docker_hub_versioned_tools() {
1711        for (server, expected) in [
1712            ("kanidm/server:1.11.2", "kanidm/tools:1.11.2"),
1713            ("kanidm/server:latest", "kanidm/tools:latest"),
1714            ("kanidm/server", "kanidm/tools:latest"),
1715            (
1716                "kanidm/server:1.11.2@sha256:deadbeef",
1717                "kanidm/tools:1.11.2",
1718            ),
1719        ] {
1720            assert_eq!(default_mail_sender_image(server).unwrap(), expected);
1721        }
1722    }
1723
1724    #[test]
1725    fn digest_only_server_image_requires_explicit_mail_sender_image() {
1726        assert!(default_mail_sender_image("kanidm/server@sha256:deadbeef").is_err());
1727    }
1728
1729    #[test]
1730    fn toml_basic_string_escapes_config_values() {
1731        assert_eq!(
1732            toml_basic_string("quoted \"value\" with \\ slash\nand tab\t"),
1733            r#""quoted \"value\" with \\ slash\nand tab\t""#
1734        );
1735    }
1736
1737    #[test]
1738    fn group_contains_member_matches_bare_name_against_spn() {
1739        let members = vec![
1740            "other-user".to_string(),
1741            "my-sa@idm.example.com".to_string(),
1742        ];
1743        assert!(group_contains_member(&members, "my-sa"));
1744    }
1745
1746    #[test]
1747    fn group_contains_member_is_case_insensitive() {
1748        let members = vec!["My-SA@idm.example.com".to_string()];
1749        assert!(group_contains_member(&members, "my-sa"));
1750    }
1751
1752    #[test]
1753    fn group_contains_member_returns_false_for_empty() {
1754        let members: Vec<String> = vec![];
1755        assert!(!group_contains_member(&members, "my-sa"));
1756    }
1757
1758    #[test]
1759    fn group_contains_member_returns_false_when_no_match() {
1760        let members = vec![
1761            "other-user".to_string(),
1762            "another-sa@idm.example.com".to_string(),
1763        ];
1764        assert!(!group_contains_member(&members, "my-sa"));
1765    }
1766}