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