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::REPLICA_LABEL;
4
5use kaniop_k8s_util::error::{Error, Result};
6
7use std::sync::Arc;
8
9use k8s_openapi::api::core::v1::Secret;
10use kube::ResourceExt;
11use kube::api::{ObjectMeta, Resource};
12use serde::Serialize;
13use tracing::info;
14
15pub const ADMIN_PASSWORD_KEY: &str = "ADMIN_PASSWORD";
16pub const ADMIN_USER: &str = "admin";
17pub const IDM_ADMIN_PASSWORD_KEY: &str = "IDM_ADMIN_PASSWORD";
18pub const IDM_ADMIN_USER: &str = "idm_admin";
19pub const SECRET_TYPE_LABEL: &str = "kaniop.rs/secret-type";
20// decode with `basenc --base64url -d | openssl x509 -noout -text -inform DER`
21pub const REPLICA_SECRET_KEY: &str = "tls.der.b64url";
22
23#[allow(async_fn_in_trait)]
24pub trait SecretExt {
25    fn admins_secret_name(&self) -> String;
26    fn replica_secret_name(&self, pod_name: &str) -> String;
27    async fn generate_admins_secret(&self, ctx: Arc<Context>) -> Result<Secret>;
28    async fn generate_replica_secret(&self, ctx: Arc<Context>, pod_name: &str) -> Result<Secret>;
29    async fn update_replica_secret(&self, ctx: Arc<Context>, pod_name: &str) -> Result<Secret>;
30}
31
32#[derive(Serialize, Debug)]
33#[serde(rename_all = "kebab-case")]
34pub enum SecretType {
35    AdminPasswords,
36    ReplicaCert,
37}
38
39impl SecretExt for Kanidm {
40    #[inline]
41    fn admins_secret_name(&self) -> String {
42        format!("{}-admin-passwords", self.name_any())
43    }
44
45    #[inline]
46    fn replica_secret_name(&self, pod_name: &str) -> String {
47        format!("{pod_name}-cert")
48    }
49
50    async fn generate_admins_secret(&self, ctx: Arc<Context>) -> Result<Secret> {
51        let admin_password = self.recover_password(ctx.clone(), ADMIN_USER).await?;
52        let idm_admin_password = self.recover_password(ctx.clone(), IDM_ADMIN_USER).await?;
53
54        let secret = Secret {
55            metadata: ObjectMeta {
56                name: Some(self.admins_secret_name()),
57                namespace: Some(self.namespace().unwrap()),
58                owner_references: self.controller_owner_ref(&()).map(|oref| vec![oref]),
59                annotations: self
60                    .spec
61                    .service
62                    .as_ref()
63                    .and_then(|s| s.annotations.clone()),
64                labels: Some(
65                    self.generate_resource_labels()
66                        .clone()
67                        .into_iter()
68                        .chain(std::iter::once((
69                            SECRET_TYPE_LABEL.to_string(),
70                            serde_plain::to_string(&SecretType::AdminPasswords).unwrap(),
71                        )))
72                        .collect(),
73                ),
74                ..ObjectMeta::default()
75            },
76            string_data: Some(
77                [
78                    ("ADMIN_USERNAME".to_string(), ADMIN_USER.to_string()),
79                    (ADMIN_PASSWORD_KEY.to_string(), admin_password),
80                    ("IDM_ADMIN_USERNAME".to_string(), IDM_ADMIN_USER.to_string()),
81                    (IDM_ADMIN_PASSWORD_KEY.to_string(), idm_admin_password),
82                ]
83                .iter()
84                .cloned()
85                .collect(),
86            ),
87            ..Secret::default()
88        };
89
90        Ok(secret)
91    }
92
93    async fn generate_replica_secret(&self, ctx: Arc<Context>, pod_name: &str) -> Result<Secret> {
94        let cert = self.get_replica_cert(ctx.clone(), pod_name).await?;
95        let secret = self.build_replica_secret(cert, pod_name);
96        Ok(secret)
97    }
98
99    async fn update_replica_secret(&self, ctx: Arc<Context>, pod_name: &str) -> Result<Secret> {
100        info!(msg = format!("renewing replica certificate for pod {pod_name}"));
101        let cert = self.update_replica_cert(ctx.clone(), pod_name).await?;
102        let secret = self.build_replica_secret(cert, pod_name);
103        Ok(secret)
104    }
105}
106
107impl Kanidm {
108    async fn recover_password(&self, ctx: Arc<Context>, user: &str) -> Result<String, Error> {
109        let recover_command = vec!["kanidmd", "recover-account"];
110        let password_output = self
111            .exec_any(
112                ctx.clone(),
113                recover_command.into_iter().chain(std::iter::once(user)),
114            )
115            .await
116            .map_err(|e| match e {
117                Error::KubeExecError(_) => {
118                    Error::ReceiveOutput(format!("failed to recover password for {user}"))
119                }
120                _ => e,
121            })?;
122        extract_password(password_output)
123    }
124
125    fn build_replica_secret(&self, cert: String, pod_name: &str) -> Secret {
126        Secret {
127            metadata: ObjectMeta {
128                name: Some(self.replica_secret_name(pod_name)),
129                namespace: Some(self.namespace().unwrap()),
130                owner_references: self.controller_owner_ref(&()).map(|oref| vec![oref]),
131                annotations: self
132                    .spec
133                    .service
134                    .as_ref()
135                    .and_then(|s| s.annotations.clone()),
136                labels: Some(
137                    self.generate_resource_labels()
138                        .clone()
139                        .into_iter()
140                        .chain([
141                            (REPLICA_LABEL.to_string(), pod_name.to_string()),
142                            (
143                                SECRET_TYPE_LABEL.to_string(),
144                                serde_plain::to_string(&SecretType::ReplicaCert).unwrap(),
145                            ),
146                        ])
147                        .collect(),
148                ),
149                ..ObjectMeta::default()
150            },
151            string_data: Some(
152                [(REPLICA_SECRET_KEY.to_string(), cert)]
153                    .iter()
154                    .cloned()
155                    .collect(),
156            ),
157            ..Secret::default()
158        }
159    }
160
161    async fn get_replica_cert(&self, ctx: Arc<Context>, pod_name: &str) -> Result<String, Error> {
162        let show_certificate_command = vec!["kanidmd", "show-replication-certificate"];
163        let cert_output = self
164            .exec(ctx.clone(), pod_name, show_certificate_command)
165            .await
166            .map_err(|e| match e {
167                Error::KubeExecError(_) => {
168                    Error::ReceiveOutput(format!("failed to get certificate for {pod_name}"))
169                }
170                _ => e,
171            })?;
172        extract_cert(cert_output)
173    }
174
175    async fn update_replica_cert(
176        &self,
177        ctx: Arc<Context>,
178        pod_name: &str,
179    ) -> Result<String, Error> {
180        let renew_command = vec!["kanidmd", "renew-replication-certificate"];
181        let cert_output = self
182            .exec(ctx.clone(), pod_name, renew_command)
183            .await
184            .map_err(|e| {
185                Error::ReceiveOutput(format!("failed to renew certificate for {pod_name}: {e}"))
186            })?;
187        extract_cert(cert_output)
188    }
189}
190
191fn extract_password(output: String) -> Result<String, Error> {
192    let pattern = r#"new_password: ""#;
193    if let Some(start_index) = output.find(pattern) {
194        let start = start_index + pattern.len();
195        if let Some(end_index) = output[start..].find('"') {
196            return Ok(output[start..start + end_index].to_string());
197        }
198    }
199    Err(Error::ReceiveOutput("password was not found".to_string()))
200}
201
202fn extract_cert(output: String) -> Result<String, Error> {
203    let start_pattern = r#"certificate: ""#;
204    if let Some(start_index) = output.find(start_pattern) {
205        let start = start_index + start_pattern.len();
206        if let Some(end_index) = output[start..].find('"') {
207            return Ok(output[start..start + end_index].to_string());
208        }
209    }
210    Err(Error::ReceiveOutput(
211        "certificate was not found".to_string(),
212    ))
213}
214
215#[cfg(test)]
216mod tests {
217    use super::*;
218
219    #[test]
220    fn test_extract_password() {
221        let output = r#"
222        00000000-0000-0000-0000-000000000000 WARN     🚧 [warn]: This is running as uid == 0 (root) which may be a security risk.
223        00000000-0000-0000-0000-000000000000 WARN     🚧 [warn]: WARNING: DB folder /data has 'everyone' permission bits in the mode. This could be a security risk ...
224        00000000-0000-0000-0000-000000000000 INFO     i [info]: Running account recovery ...
225        00000000-0000-0000-0000-000000000000 INFO     i [info]:  | new_password: "ZJhV4PU18qrf7x2AJGTJvS1LyQbh7v9ZER8aZrFu9Evc9sqH""#.to_string();
226
227        let result = extract_password(output).unwrap();
228        assert_eq!(result, "ZJhV4PU18qrf7x2AJGTJvS1LyQbh7v9ZER8aZrFu9Evc9sqH");
229    }
230
231    #[test]
232    fn test_extract_cert() {
233        let output = r#"
234        00000000-0000-0000-0000-000000000000 WARN     🚧 [warn]: This is running as uid == 0 (root) which may be a security risk.
235        00000000-0000-0000-0000-000000000000 WARN     🚧 [warn]: WARNING: DB folder /data has 'everyone' permission bits in the mode. This could be a security risk ...
236        00000000-0000-0000-0000-000000000000 INFO     i [info]: Running show replication certificate ...
237        00000000-0000-0000-0000-000000000000 INFO     i [info]:  | certificate: "MIIB_DCCAaGgAwIBAgIBATAKBggqhkjOPQQDAjBMMRswGQYDVQQKDBJLYW5pZG0gUmVwbGljYXRpb24xLTArBgNVBAMMJDJiYTgzMTZhLWViYWEtNGJjMS04NDkzLTVmODZmYWZhZTU5NDAeFw0yNDExMDYxOTEzMjdaFw0yODExMDYxOTEzMjdaMEwxGzAZBgNVBAoMEkthbmlkbSBSZXBsaWNhdGlvbjEtMCsGA1UEAwwkMmJhODMxNmEtZWJhYS00YmMxLTg0OTMtNWY4NmZhZmFlNTk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEuXp1hNNZerxDQbCh7rAGW6uM0CPECNd3IvbSh7qH34MkO_plwwDVKFbzcTG8HJE2ouIJlJYN8P4wf6qmrRQMAKN0MHIwDAYDVR0TAQH_BAIwADAOBgNVHQ8BAf8EBAMCBaAwHQYDVR0lBBYwFAYIKwYBBQUHAwEGCCsGAQUFBwMCMB0GA1UdDgQWBBTaOaPuXmtLDTJVv--VYBiQr9gHCTAUBgNVHREEDTALgglsb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAIZD_J4LyR7D0kg41GRg_TcRxm5mEVhM6WL9BO3XmfUsAiEA7Wpbkvd0b1e-Sg8AS9jP-CpBpmTnC7oEChkyhUYKyFc=""#.to_string();
238
239        let result = extract_cert(output).unwrap();
240        assert_eq!(
241            result,
242            "MIIB_DCCAaGgAwIBAgIBATAKBggqhkjOPQQDAjBMMRswGQYDVQQKDBJLYW5pZG0gUmVwbGljYXRpb24xLTArBgNVBAMMJDJiYTgzMTZhLWViYWEtNGJjMS04NDkzLTVmODZmYWZhZTU5NDAeFw0yNDExMDYxOTEzMjdaFw0yODExMDYxOTEzMjdaMEwxGzAZBgNVBAoMEkthbmlkbSBSZXBsaWNhdGlvbjEtMCsGA1UEAwwkMmJhODMxNmEtZWJhYS00YmMxLTg0OTMtNWY4NmZhZmFlNTk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEuXp1hNNZerxDQbCh7rAGW6uM0CPECNd3IvbSh7qH34MkO_plwwDVKFbzcTG8HJE2ouIJlJYN8P4wf6qmrRQMAKN0MHIwDAYDVR0TAQH_BAIwADAOBgNVHQ8BAf8EBAMCBaAwHQYDVR0lBBYwFAYIKwYBBQUHAwEGCCsGAQUFBwMCMB0GA1UdDgQWBBTaOaPuXmtLDTJVv--VYBiQr9gHCTAUBgNVHREEDTALgglsb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAIZD_J4LyR7D0kg41GRg_TcRxm5mEVhM6WL9BO3XmfUsAiEA7Wpbkvd0b1e-Sg8AS9jP-CpBpmTnC7oEChkyhUYKyFc="
243        );
244    }
245}