kaniop_operator/kanidm/reconcile/
secret.rs

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