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