Skip to main content

kaniop_operator/kanidm/reconcile/
secret.rs

1use crate::kanidm::controller::context::Context;
2use crate::kanidm::crd::Kanidm;
3use crate::kanidm::reconcile::statefulset::{KANIDM_CONFIG_PATH, REPLICA_LABEL};
4
5use kaniop_k8s_util::error::{Error, Result};
6
7use std::sync::{Arc, LazyLock};
8
9use k8s_openapi::api::core::v1::Secret;
10use kube::ResourceExt;
11use kube::api::{ObjectMeta, Resource};
12use regex::Regex;
13use serde::Serialize;
14use tracing::info;
15
16pub const ADMIN_PASSWORD_KEY: &str = "ADMIN_PASSWORD";
17pub const ADMIN_USER: &str = "admin";
18pub const IDM_ADMIN_PASSWORD_KEY: &str = "IDM_ADMIN_PASSWORD";
19pub const IDM_ADMIN_USER: &str = "idm_admin";
20pub const SECRET_TYPE_LABEL: &str = "kaniop.rs/secret-type";
21// decode with `basenc --base64url -d | openssl x509 -noout -text -inform DER`
22pub const REPLICA_SECRET_KEY: &str = "tls.der.b64url";
23
24#[allow(async_fn_in_trait)]
25pub trait SecretExt {
26    fn admins_secret_name(&self) -> String;
27    fn replica_secret_name(&self, pod_name: &str) -> String;
28    async fn generate_admins_secret(&self, ctx: Arc<Context>) -> Result<Secret>;
29    async fn generate_replica_secret(&self, ctx: Arc<Context>, pod_name: &str) -> Result<Secret>;
30    async fn update_replica_secret(&self, ctx: Arc<Context>, pod_name: &str) -> Result<Secret>;
31}
32
33#[derive(Serialize, Debug)]
34#[serde(rename_all = "kebab-case")]
35pub enum SecretType {
36    AdminPasswords,
37    ReplicaCert,
38}
39
40impl SecretExt for Kanidm {
41    #[inline]
42    fn admins_secret_name(&self) -> String {
43        format!("{}-admin-passwords", self.name_any())
44    }
45
46    #[inline]
47    fn replica_secret_name(&self, pod_name: &str) -> String {
48        format!("{pod_name}-cert")
49    }
50
51    async fn generate_admins_secret(&self, ctx: Arc<Context>) -> Result<Secret> {
52        let admin_password = self.recover_password(ctx.clone(), ADMIN_USER).await?;
53        let idm_admin_password = self.recover_password(ctx.clone(), IDM_ADMIN_USER).await?;
54
55        let secret = Secret {
56            metadata: ObjectMeta {
57                name: Some(self.admins_secret_name()),
58                namespace: Some(self.namespace().unwrap()),
59                owner_references: self.controller_owner_ref(&()).map(|oref| vec![oref]),
60                annotations: self
61                    .spec
62                    .service
63                    .as_ref()
64                    .and_then(|s| s.annotations.clone()),
65                labels: Some(
66                    self.generate_resource_labels()
67                        .clone()
68                        .into_iter()
69                        .chain(std::iter::once((
70                            SECRET_TYPE_LABEL.to_string(),
71                            serde_plain::to_string(&SecretType::AdminPasswords).unwrap(),
72                        )))
73                        .collect(),
74                ),
75                ..ObjectMeta::default()
76            },
77            string_data: Some(
78                [
79                    ("ADMIN_USERNAME".to_string(), ADMIN_USER.to_string()),
80                    (ADMIN_PASSWORD_KEY.to_string(), admin_password),
81                    ("IDM_ADMIN_USERNAME".to_string(), IDM_ADMIN_USER.to_string()),
82                    (IDM_ADMIN_PASSWORD_KEY.to_string(), idm_admin_password),
83                ]
84                .iter()
85                .cloned()
86                .collect(),
87            ),
88            ..Secret::default()
89        };
90
91        Ok(secret)
92    }
93
94    async fn generate_replica_secret(&self, ctx: Arc<Context>, pod_name: &str) -> Result<Secret> {
95        let cert = self.get_replica_cert(ctx.clone(), pod_name).await?;
96        let secret = self.build_replica_secret(cert, pod_name);
97        Ok(secret)
98    }
99
100    async fn update_replica_secret(&self, ctx: Arc<Context>, pod_name: &str) -> Result<Secret> {
101        info!(msg = format!("renewing replica certificate for pod {pod_name}"));
102        let cert = self.update_replica_cert(ctx.clone(), pod_name).await?;
103        let secret = self.build_replica_secret(cert, pod_name);
104        Ok(secret)
105    }
106}
107
108impl Kanidm {
109    async fn recover_password(&self, ctx: Arc<Context>, user: &str) -> Result<String, Error> {
110        let recover_command = vec!["kanidmd", "recover-account"];
111        let password_output = self
112            .exec_any(
113                ctx.clone(),
114                recover_command.into_iter().chain(std::iter::once(user)),
115            )
116            .await
117            .map_err(|e| match e {
118                Error::KubeExecError(_) => {
119                    Error::ReceiveOutput(format!("failed to recover password for {user}"))
120                }
121                _ => e,
122            })?;
123        extract_password(password_output)
124    }
125
126    fn build_replica_secret(&self, cert: String, pod_name: &str) -> Secret {
127        Secret {
128            metadata: ObjectMeta {
129                name: Some(self.replica_secret_name(pod_name)),
130                namespace: Some(self.namespace().unwrap()),
131                owner_references: self.controller_owner_ref(&()).map(|oref| vec![oref]),
132                annotations: self
133                    .spec
134                    .service
135                    .as_ref()
136                    .and_then(|s| s.annotations.clone()),
137                labels: Some(
138                    self.generate_resource_labels()
139                        .clone()
140                        .into_iter()
141                        .chain([
142                            (REPLICA_LABEL.to_string(), pod_name.to_string()),
143                            (
144                                SECRET_TYPE_LABEL.to_string(),
145                                serde_plain::to_string(&SecretType::ReplicaCert).unwrap(),
146                            ),
147                        ])
148                        .collect(),
149                ),
150                ..ObjectMeta::default()
151            },
152            string_data: Some(
153                [(REPLICA_SECRET_KEY.to_string(), cert)]
154                    .iter()
155                    .cloned()
156                    .collect(),
157            ),
158            ..Secret::default()
159        }
160    }
161
162    async fn get_replica_cert(&self, ctx: Arc<Context>, pod_name: &str) -> Result<String, Error> {
163        let show_certificate_command = vec![
164            "kanidmd",
165            "show-replication-certificate",
166            "-c",
167            KANIDM_CONFIG_PATH,
168        ];
169        let cert_output = self
170            .exec(ctx.clone(), pod_name, show_certificate_command)
171            .await
172            .map_err(|e| match e {
173                Error::KubeExecError(_) => {
174                    Error::ReceiveOutput(format!("failed to get certificate for {pod_name}"))
175                }
176                _ => e,
177            })?;
178        extract_cert(cert_output)
179    }
180
181    async fn update_replica_cert(
182        &self,
183        ctx: Arc<Context>,
184        pod_name: &str,
185    ) -> Result<String, Error> {
186        let renew_command = vec![
187            "kanidmd",
188            "renew-replication-certificate",
189            "-c",
190            KANIDM_CONFIG_PATH,
191        ];
192        let cert_output = self
193            .exec(ctx.clone(), pod_name, renew_command)
194            .await
195            .map_err(|e| {
196                Error::ReceiveOutput(format!("failed to renew certificate for {pod_name}: {e}"))
197            })?;
198        extract_cert(cert_output)
199    }
200}
201
202static PASSWORD_REGEX: LazyLock<Regex> = LazyLock::new(|| {
203    Regex::new(r#"new_password:\s*"([^"]+)"#).expect("password regex must be valid")
204});
205
206static CERT_REGEX_V1_9: LazyLock<Regex> = LazyLock::new(|| {
207    Regex::new(r#"certificate:\s*"([^"]+)"#).expect("certificate regex (v1.9) must be valid")
208});
209
210static CERT_REGEX_V1_10: LazyLock<Regex> = LazyLock::new(|| {
211    Regex::new(r#"certificate=([A-Za-z0-9_+/=-]+)"#)
212        .expect("certificate regex (v1.10) must be valid")
213});
214
215fn extract_password(output: String) -> Result<String, Error> {
216    PASSWORD_REGEX
217        .captures(&output)
218        .and_then(|caps| caps.get(1))
219        .map(|m| m.as_str().to_string())
220        .ok_or_else(|| Error::ReceiveOutput("password was not found".to_string()))
221}
222
223fn extract_cert(output: String) -> Result<String, Error> {
224    if let Some(caps) = CERT_REGEX_V1_9.captures(&output) {
225        caps.get(1)
226            .map(|m| m.as_str().to_string())
227            .ok_or_else(|| Error::ReceiveOutput("certificate was not found (v1.9)".to_string()))
228    } else {
229        CERT_REGEX_V1_10
230            .captures(&output)
231            .and_then(|caps| caps.get(1))
232            .map(|m| m.as_str().to_string())
233            .ok_or_else(|| Error::ReceiveOutput("certificate was not found".to_string()))
234    }
235}
236
237#[cfg(test)]
238mod tests {
239    use super::*;
240
241    #[test]
242    fn test_extract_password() {
243        let output = r#"
244        00000000-0000-0000-0000-000000000000 WARN     🚧 [warn]: This is running as uid == 0 (root) which may be a security risk.
245        00000000-0000-0000-0000-000000000000 WARN     🚧 [warn]: WARNING: DB folder /data has 'everyone' permission bits in the mode. This could be a security risk ...
246        00000000-0000-0000-0000-000000000000 INFO     i [info]: Running account recovery ...
247        00000000-0000-0000-0000-000000000000 INFO     i [info]:  | new_password: "ZJhV4PU18qrf7x2AJGTJvS1LyQbh7v9ZER8aZrFu9Evc9sqH""#.to_string();
248
249        let result = extract_password(output).unwrap();
250        assert_eq!(result, "ZJhV4PU18qrf7x2AJGTJvS1LyQbh7v9ZER8aZrFu9Evc9sqH");
251    }
252
253    #[test]
254    fn test_extract_password_with_otel_tracing() {
255        let output = r#"
256        2026-05-07T18:10:01.000000Z INFO kanidmd::recover_account: Running account recovery
257        trace_id=12345 span_id=67890
258        2026-05-07T18:10:01.000000Z INFO kanidmd::recover_account:new_password: "OTELTestPassword123456789ABCDEFG"
259        trace_id=12345 span_id=67890"#.to_string();
260
261        let result = extract_password(output).unwrap();
262        assert_eq!(result, "OTELTestPassword123456789ABCDEFG");
263    }
264
265    #[test]
266    fn test_extract_password_with_extra_whitespace() {
267        let output = r#"
268        Running account recovery ...
269         | new_password:     "WhitespaceTestPassword12345"  "#
270            .to_string();
271
272        let result = extract_password(output).unwrap();
273        assert_eq!(result, "WhitespaceTestPassword12345");
274    }
275
276    #[test]
277    fn test_extract_cert() {
278        let output = r#"
279        00000000-0000-0000-0000-000000000000 WARN     🚧 [warn]: This is running as uid == 0 (root) which may be a security risk.
280        00000000-0000-0000-0000-000000000000 WARN     🚧 [warn]: WARNING: DB folder /data has 'everyone' permission bits in the mode. This could be a security risk ...
281        00000000-0000-0000-0000-000000000000 INFO     i [info]: Running show replication certificate ...
282        00000000-0000-0000-0000-000000000000 INFO     i [info]:  | certificate: "MIIB_DCCAaGgAwIBAgIBATAKBggqhkjOPQQDAjBMMRswGQYDVQQKDBJLYW5pZG0gUmVwbGljYXRpb24xLTArBgNVBAMMJDJiYTgzMTZhLWViYWEtNGJjMS04NDkzLTVmODZmYWZhZTU5NDAeFw0yNDExMDYxOTEzMjdaFw0yODExMDYxOTEzMjdaMEwxGzAZBgNVBAoMEkthbmlkbSBSZXBsaWNhdGlvbjEtMCsGA1UEAwwkMmJhODMxNmEtZWJhYS00YmMxLTg0OTMtNWY4NmZhZmFlNTk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEuXp1hNNZerxDQbCh7rAGW6uM0CPECNd3IvbSh7qH34MkO_plwwDVKFbzcTG8HJE2ouIJlJYN8P4wf6qmrRQMAKN0MHIwDAYDVR0TAQH_BAIwADAOBgNVHQ8BAf8EBAMCBaAwHQYDVR0lBBYwFAYIKwYBBQUHAwEGCCsGAQUFBwMCMB0GA1UdDgQWBBTaOaPuXmtLDTJVv--VYBiQr9gHCTAUBgNVHREEDTALgglsb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAIZD_J4LyR7D0kg41GRg_TcRxm5mEVhM6WL9BO3XmfUsAiEA7Wpbkvd0b1e-Sg8AS9jP-CpBpmTnC7oEChkyhUYKyFc=""#.to_string();
283
284        let result = extract_cert(output).unwrap();
285        assert_eq!(
286            result,
287            "MIIB_DCCAaGgAwIBAgIBATAKBggqhkjOPQQDAjBMMRswGQYDVQQKDBJLYW5pZG0gUmVwbGljYXRpb24xLTArBgNVBAMMJDJiYTgzMTZhLWViYWEtNGJjMS04NDkzLTVmODZmYWZhZTU5NDAeFw0yNDExMDYxOTEzMjdaFw0yODExMDYxOTEzMjdaMEwxGzAZBgNVBAoMEkthbmlkbSBSZXBsaWNhdGlvbjEtMCsGA1UEAwwkMmJhODMxNmEtZWJhYS00YmMxLTg0OTMtNWY4NmZhZmFlNTk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEuXp1hNNZerxDQbCh7rAGW6uM0CPECNd3IvbSh7qH34MkO_plwwDVKFbzcTG8HJE2ouIJlJYN8P4wf6qmrRQMAKN0MHIwDAYDVR0TAQH_BAIwADAOBgNVHQ8BAf8EBAMCBaAwHQYDVR0lBBYwFAYIKwYBBQUHAwEGCCsGAQUFBwMCMB0GA1UdDgQWBBTaOaPuXmtLDTJVv--VYBiQr9gHCTAUBgNVHREEDTALgglsb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAIZD_J4LyR7D0kg41GRg_TcRxm5mEVhM6WL9BO3XmfUsAiEA7Wpbkvd0b1e-Sg8AS9jP-CpBpmTnC7oEChkyhUYKyFc="
288        );
289    }
290
291    #[test]
292    fn test_extract_cert_with_otel_tracing() {
293        let output = r#"
294        2026-05-07T18:10:01.000000Z INFO kanidmd::show_certificate: Running show replication certificate
295        trace_id=12345 span_id=67890
296        2026-05-07T18:10:01.000000Z INFO kanidmd::show_certificate:certificate: "MIIBTestCertificateForOTELTracing123456789"
297        trace_id=12345 span_id=67890"#.to_string();
298
299        let result = extract_cert(output).unwrap();
300        assert_eq!(result, "MIIBTestCertificateForOTELTracing123456789");
301    }
302
303    #[test]
304    fn test_extract_cert_with_extra_whitespace() {
305        let output = r#"
306        Running show replication certificate ...
307         | certificate:     "WhitespaceTestCert12345"  "#
308            .to_string();
309
310        let result = extract_cert(output).unwrap();
311        assert_eq!(result, "WhitespaceTestCert12345");
312    }
313
314    #[test]
315    fn test_extract_cert_v1_10_format() {
316        let output = r#"
317        2026-05-07T18:10:01.000000Z INFO kanidmd::show_certificate: Running show replication certificate
318        2026-05-07T18:10:01.000000Z INFO kanidmd::show_certificate:certificate=MIIB_DCCAaGgAwIBAgIBATAKBggqhkjOPQQDAjBMMRswGQYDVQQKDBJLYW5pZG0gUmVwbGljYXRpb24xLTArBgNVBAMMJDJiYTgzMTZhLWViYWEtNGJjMS04NDkzLTVmODZmYWZhZTU5NDAeFw0yNDExMDYxOTEzMjdaFw0yODExMDYxOTEzMjdaMEwxGzAZBgNVBAoMEkthbmlkbSBSZXBsaWNhdGlvbjEtMCsGA1UEAwwkMmJhODMxNmEtZWJhYS00YmMxLTg0OTMtNWY4NmZhZmFlNTk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEuXp1hNNZerxDQbCh7rAGW6uM0CPECNd3IvbSh7qH34MkO_plwwDVKFbzcTG8HJE2ouIJlJYN8P4wf6qmrRQMAKN0MHIwDAYDVR0TAQH_BAIwADAOBgNVHQ8BAf8EBAMCBaAwHQYDVR0lBBYwFAYIKwYBBQUHAwEGCCsGAQUFBwMCMB0GA1UdDgQWBBTaOaPuXmtLDTJVv--VYBiQr9gHCTAUBgNVHREEDTALgglsb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAIZD_J4LyR7D0kg41GRg_TcRxm5mEVhM6WL9BO3XmfUsAiEA7Wpbkvd0b1e-Sg8AS9jP-CpBpmTnC7oEChkyhUYKyFc="#.to_string();
319
320        let result = extract_cert(output).unwrap();
321        assert_eq!(
322            result,
323            "MIIB_DCCAaGgAwIBAgIBATAKBggqhkjOPQQDAjBMMRswGQYDVQQKDBJLYW5pZG0gUmVwbGljYXRpb24xLTArBgNVBAMMJDJiYTgzMTZhLWViYWEtNGJjMS04NDkzLTVmODZmYWZhZTU5NDAeFw0yNDExMDYxOTEzMjdaFw0yODExMDYxOTEzMjdaMEwxGzAZBgNVBAoMEkthbmlkbSBSZXBsaWNhdGlvbjEtMCsGA1UEAwwkMmJhODMxNmEtZWJhYS00YmMxLTg0OTMtNWY4NmZhZmFlNTk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEuXp1hNNZerxDQbCh7rAGW6uM0CPECNd3IvbSh7qH34MkO_plwwDVKFbzcTG8HJE2ouIJlJYN8P4wf6qmrRQMAKN0MHIwDAYDVR0TAQH_BAIwADAOBgNVHQ8BAf8EBAMCBaAwHQYDVR0lBBYwFAYIKwYBBQUHAwEGCCsGAQUFBwMCMB0GA1UdDgQWBBTaOaPuXmtLDTJVv--VYBiQr9gHCTAUBgNVHREEDTALgglsb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAIZD_J4LyR7D0kg41GRg_TcRxm5mEVhM6WL9BO3XmfUsAiEA7Wpbkvd0b1e-Sg8AS9jP-CpBpmTnC7oEChkyhUYKyFc="
324        );
325    }
326}