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