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