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