kaniop_operator/kanidm/reconcile/
secret.rs

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