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 serde_json::Value;
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(self.labels().clone())
70                        .chain(std::iter::once((
71                            SECRET_TYPE_LABEL.to_string(),
72                            serde_plain::to_string(&SecretType::AdminPasswords).unwrap(),
73                        )))
74                        .collect(),
75                ),
76                ..ObjectMeta::default()
77            },
78            string_data: Some(
79                [
80                    ("ADMIN_USERNAME".to_string(), ADMIN_USER.to_string()),
81                    (ADMIN_PASSWORD_KEY.to_string(), admin_password),
82                    ("IDM_ADMIN_USERNAME".to_string(), IDM_ADMIN_USER.to_string()),
83                    (IDM_ADMIN_PASSWORD_KEY.to_string(), idm_admin_password),
84                ]
85                .iter()
86                .cloned()
87                .collect(),
88            ),
89            ..Secret::default()
90        };
91
92        Ok(secret)
93    }
94
95    async fn generate_replica_secret(&self, ctx: Arc<Context>, pod_name: &str) -> Result<Secret> {
96        let cert = self.get_replica_cert(ctx.clone(), pod_name).await?;
97        let secret = self.build_replica_secret(cert, pod_name);
98        Ok(secret)
99    }
100
101    async fn update_replica_secret(&self, ctx: Arc<Context>, pod_name: &str) -> Result<Secret> {
102        info!(msg = format!("renewing replica certificate for pod {pod_name}"));
103        let cert = self.update_replica_cert(ctx.clone(), pod_name).await?;
104        let secret = self.build_replica_secret(cert, pod_name);
105        Ok(secret)
106    }
107}
108
109impl Kanidm {
110    async fn recover_password(&self, ctx: Arc<Context>, user: &str) -> Result<String, Error> {
111        let recover_command = vec!["kanidmd", "recover-account", "--output", "json"];
112        let password_output = self
113            .exec_any(
114                ctx.clone(),
115                recover_command.into_iter().chain(std::iter::once(user)),
116            )
117            .await
118            .map_err(|e| match e {
119                Error::KubeExecError(_) => {
120                    Error::ReceiveOutput(format!("failed to recover password for {user}"))
121                }
122                _ => e,
123            })?;
124        extract_password(password_output)
125    }
126
127    fn build_replica_secret(&self, cert: String, pod_name: &str) -> Secret {
128        Secret {
129            metadata: ObjectMeta {
130                name: Some(self.replica_secret_name(pod_name)),
131                namespace: Some(self.namespace().unwrap()),
132                owner_references: self.controller_owner_ref(&()).map(|oref| vec![oref]),
133                annotations: self
134                    .spec
135                    .service
136                    .as_ref()
137                    .and_then(|s| s.annotations.clone()),
138                labels: Some(
139                    self.generate_resource_labels()
140                        .clone()
141                        .into_iter()
142                        .chain(self.labels().clone())
143                        .chain([
144                            (REPLICA_LABEL.to_string(), pod_name.to_string()),
145                            (
146                                SECRET_TYPE_LABEL.to_string(),
147                                serde_plain::to_string(&SecretType::ReplicaCert).unwrap(),
148                            ),
149                        ])
150                        .collect(),
151                ),
152                ..ObjectMeta::default()
153            },
154            string_data: Some(
155                [(REPLICA_SECRET_KEY.to_string(), cert)]
156                    .iter()
157                    .cloned()
158                    .collect(),
159            ),
160            ..Secret::default()
161        }
162    }
163
164    async fn get_replica_cert(&self, ctx: Arc<Context>, pod_name: &str) -> Result<String, Error> {
165        // JSON output cannot be used here because of: https://github.com/kanidm/kanidm/pull/3179
166        // from 1.5.0+ we can use --output json
167        let show_certificate_command = vec!["kanidmd", "show-replication-certificate"];
168        let cert_output = self
169            .exec(ctx.clone(), pod_name, show_certificate_command)
170            .await
171            .map_err(|e| match e {
172                Error::KubeExecError(_) => {
173                    Error::ReceiveOutput(format!("failed to get certificate for {pod_name}"))
174                }
175                _ => e,
176            })?;
177        extract_cert(cert_output)
178    }
179
180    async fn update_replica_cert(
181        &self,
182        ctx: Arc<Context>,
183        pod_name: &str,
184    ) -> Result<String, Error> {
185        let renew_command = vec!["kanidmd", "renew-replication-certificate"];
186        let cert_output = self
187            .exec(ctx.clone(), pod_name, renew_command)
188            .await
189            .map_err(|e| {
190                Error::ReceiveOutput(format!("failed to renew certificate for {pod_name}: {e}"))
191            })?;
192        extract_cert(cert_output)
193    }
194}
195
196fn extract_password(output: String) -> Result<String, Error> {
197    let last_line = output
198        .lines()
199        .last()
200        .ok_or_else(|| Error::ReceiveOutput("no lines parsing exec output".to_string()))?;
201    let json: Value = serde_json::from_str(last_line).map_err(|e| {
202        Error::SerializationError(
203            "failed password serialization parsing exec output".to_string(),
204            e,
205        )
206    })?;
207    let password = json
208        .get("password")
209        .ok_or_else(|| {
210            Error::ReceiveOutput("no password field in JSON parsing exec output".to_string())
211        })?
212        .as_str()
213        .ok_or_else(|| {
214            Error::ReceiveOutput("password field is not a string parsing exec output".to_string())
215        })?;
216    Ok(password.to_string())
217}
218
219fn extract_cert(output: String) -> Result<String, Error> {
220    let start_pattern = r#"certificate: ""#;
221    if let Some(start_index) = output.find(start_pattern) {
222        let start = start_index + start_pattern.len();
223        if let Some(end_index) = output[start..].find('"') {
224            return Ok(output[start..start + end_index].to_string());
225        }
226    }
227    Err(Error::ReceiveOutput(
228        "certificate was not found".to_string(),
229    ))
230}
231
232#[cfg(test)]
233mod tests {
234    use super::*;
235
236    #[test]
237    fn test_extract_password() {
238        let output = r#"
239        00000000-0000-0000-0000-000000000000 WARN     🚧 [warn]: This is running as uid == 0 (root) which may be a security risk.
240        00000000-0000-0000-0000-000000000000 WARN     🚧 [warn]: WARNING: DB folder /data has 'everyone' permission bits in the mode. This could be a security risk ...
241        00000000-0000-0000-0000-000000000000 INFO     i [info]: Running account recovery ...
242        {"password":"ZJhV4PU18qrf7x2AJGTJvS1LyQbh7v9ZER8aZrFu9Evc9sqH"}"#.to_string();
243
244        let result = extract_password(output).unwrap();
245        assert_eq!(result, "ZJhV4PU18qrf7x2AJGTJvS1LyQbh7v9ZER8aZrFu9Evc9sqH");
246    }
247
248    #[test]
249    fn test_extract_cert() {
250        let output = r#"
251        00000000-0000-0000-0000-000000000000 WARN     🚧 [warn]: This is running as uid == 0 (root) which may be a security risk.
252        00000000-0000-0000-0000-000000000000 WARN     🚧 [warn]: WARNING: DB folder /data has 'everyone' permission bits in the mode. This could be a security risk ...
253        00000000-0000-0000-0000-000000000000 INFO     i [info]: Running show replication certificate ...
254        00000000-0000-0000-0000-000000000000 INFO     i [info]:  | certificate: "MIIB_DCCAaGgAwIBAgIBATAKBggqhkjOPQQDAjBMMRswGQYDVQQKDBJLYW5pZG0gUmVwbGljYXRpb24xLTArBgNVBAMMJDJiYTgzMTZhLWViYWEtNGJjMS04NDkzLTVmODZmYWZhZTU5NDAeFw0yNDExMDYxOTEzMjdaFw0yODExMDYxOTEzMjdaMEwxGzAZBgNVBAoMEkthbmlkbSBSZXBsaWNhdGlvbjEtMCsGA1UEAwwkMmJhODMxNmEtZWJhYS00YmMxLTg0OTMtNWY4NmZhZmFlNTk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEuXp1hNNZerxDQbCh7rAGW6uM0CPECNd3IvbSh7qH34MkO_plwwDVKFbzcTG8HJE2ouIJlJYN8P4wf6qmrRQMAKN0MHIwDAYDVR0TAQH_BAIwADAOBgNVHQ8BAf8EBAMCBaAwHQYDVR0lBBYwFAYIKwYBBQUHAwEGCCsGAQUFBwMCMB0GA1UdDgQWBBTaOaPuXmtLDTJVv--VYBiQr9gHCTAUBgNVHREEDTALgglsb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAIZD_J4LyR7D0kg41GRg_TcRxm5mEVhM6WL9BO3XmfUsAiEA7Wpbkvd0b1e-Sg8AS9jP-CpBpmTnC7oEChkyhUYKyFc=""#.to_string();
255
256        let result = extract_cert(output).unwrap();
257        assert_eq!(
258            result,
259            "MIIB_DCCAaGgAwIBAgIBATAKBggqhkjOPQQDAjBMMRswGQYDVQQKDBJLYW5pZG0gUmVwbGljYXRpb24xLTArBgNVBAMMJDJiYTgzMTZhLWViYWEtNGJjMS04NDkzLTVmODZmYWZhZTU5NDAeFw0yNDExMDYxOTEzMjdaFw0yODExMDYxOTEzMjdaMEwxGzAZBgNVBAoMEkthbmlkbSBSZXBsaWNhdGlvbjEtMCsGA1UEAwwkMmJhODMxNmEtZWJhYS00YmMxLTg0OTMtNWY4NmZhZmFlNTk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEuXp1hNNZerxDQbCh7rAGW6uM0CPECNd3IvbSh7qH34MkO_plwwDVKFbzcTG8HJE2ouIJlJYN8P4wf6qmrRQMAKN0MHIwDAYDVR0TAQH_BAIwADAOBgNVHQ8BAf8EBAMCBaAwHQYDVR0lBBYwFAYIKwYBBQUHAwEGCCsGAQUFBwMCMB0GA1UdDgQWBBTaOaPuXmtLDTJVv--VYBiQr9gHCTAUBgNVHREEDTALgglsb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAIZD_J4LyR7D0kg41GRg_TcRxm5mEVhM6WL9BO3XmfUsAiEA7Wpbkvd0b1e-Sg8AS9jP-CpBpmTnC7oEChkyhUYKyFc="
260        );
261    }
262}