kaniop_operator/kanidm/reconcile/
secret.rs1use 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::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";
18pub 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 .ok_or_else(|| {
115 Error::ReceiveOutput(format!("failed to recover password for {user}"))
116 })?;
117 extract_password(password_output)
118 }
119
120 fn build_replica_secret(&self, cert: String, pod_name: &str) -> Secret {
121 Secret {
122 metadata: ObjectMeta {
123 name: Some(self.replica_secret_name(pod_name)),
124 namespace: Some(self.namespace().unwrap()),
125 owner_references: self.controller_owner_ref(&()).map(|oref| vec![oref]),
126 annotations: self
127 .spec
128 .service
129 .as_ref()
130 .and_then(|s| s.annotations.clone()),
131 labels: Some(
132 self.generate_resource_labels()
133 .clone()
134 .into_iter()
135 .chain(self.labels().clone())
136 .chain([
137 ("kaniop.rs/replica".to_string(), pod_name.to_string()),
138 (
139 SECRET_TYPE_LABEL.to_string(),
140 serde_plain::to_string(&SecretType::ReplicaCert).unwrap(),
141 ),
142 ])
143 .collect(),
144 ),
145 ..ObjectMeta::default()
146 },
147 string_data: Some(
148 [(REPLICA_SECRET_KEY.to_string(), cert)]
149 .iter()
150 .cloned()
151 .collect(),
152 ),
153 ..Secret::default()
154 }
155 }
156
157 async fn get_replica_cert(&self, ctx: Arc<Context>, pod_name: &str) -> Result<String, Error> {
158 let show_certificate_command = vec!["kanidmd", "show-replication-certificate"];
161 let cert_output = self
162 .exec(ctx.clone(), pod_name, show_certificate_command)
163 .await?
164 .ok_or_else(|| {
165 Error::ReceiveOutput(format!("failed to get certificate for {pod_name}"))
166 })?;
167 extract_cert(cert_output)
168 }
169
170 async fn update_replica_cert(
171 &self,
172 ctx: Arc<Context>,
173 pod_name: &str,
174 ) -> Result<String, Error> {
175 let renew_command = vec!["kanidmd", "renew-replication-certificate"];
176 let cert_output = self
177 .exec(ctx.clone(), pod_name, renew_command)
178 .await?
179 .ok_or_else(|| {
180 Error::ReceiveOutput(format!("failed to renew certificate for {pod_name}"))
181 })?;
182 extract_cert(cert_output)
183 }
184}
185
186fn extract_password(output: String) -> Result<String, Error> {
187 let last_line = output
188 .lines()
189 .last()
190 .ok_or_else(|| Error::ReceiveOutput("no lines parsing exec output".to_string()))?;
191 let json: Value = serde_json::from_str(last_line).map_err(|e| {
192 Error::SerializationError(
193 "failed password serialization parsing exec output".to_string(),
194 e,
195 )
196 })?;
197 let password = json
198 .get("password")
199 .ok_or_else(|| {
200 Error::ReceiveOutput("no password field in JSON parsing exec output".to_string())
201 })?
202 .as_str()
203 .ok_or_else(|| {
204 Error::ReceiveOutput("password field is not a string parsing exec output".to_string())
205 })?;
206 Ok(password.to_string())
207}
208
209fn extract_cert(output: String) -> Result<String, Error> {
210 let start_pattern = r#"certificate: ""#;
211 if let Some(start_index) = output.find(start_pattern) {
212 let start = start_index + start_pattern.len();
213 if let Some(end_index) = output[start..].find('"') {
214 return Ok(output[start..start + end_index].to_string());
215 }
216 }
217 Err(Error::ReceiveOutput(
218 "certificate was not found".to_string(),
219 ))
220}
221
222#[cfg(test)]
223mod tests {
224 use super::*;
225
226 #[test]
227 fn test_extract_password() {
228 let output = r#"
229 00000000-0000-0000-0000-000000000000 WARN 🚧 [warn]: This is running as uid == 0 (root) which may be a security risk.
230 00000000-0000-0000-0000-000000000000 WARN 🚧 [warn]: WARNING: DB folder /data has 'everyone' permission bits in the mode. This could be a security risk ...
231 00000000-0000-0000-0000-000000000000 INFO i [info]: Running account recovery ...
232 {"password":"ZJhV4PU18qrf7x2AJGTJvS1LyQbh7v9ZER8aZrFu9Evc9sqH"}"#.to_string();
233
234 let result = extract_password(output).unwrap();
235 assert_eq!(result, "ZJhV4PU18qrf7x2AJGTJvS1LyQbh7v9ZER8aZrFu9Evc9sqH");
236 }
237
238 #[test]
239 fn test_extract_cert() {
240 let output = r#"
241 00000000-0000-0000-0000-000000000000 WARN 🚧 [warn]: This is running as uid == 0 (root) which may be a security risk.
242 00000000-0000-0000-0000-000000000000 WARN 🚧 [warn]: WARNING: DB folder /data has 'everyone' permission bits in the mode. This could be a security risk ...
243 00000000-0000-0000-0000-000000000000 INFO i [info]: Running show replication certificate ...
244 00000000-0000-0000-0000-000000000000 INFO i [info]: | certificate: "MIIB_DCCAaGgAwIBAgIBATAKBggqhkjOPQQDAjBMMRswGQYDVQQKDBJLYW5pZG0gUmVwbGljYXRpb24xLTArBgNVBAMMJDJiYTgzMTZhLWViYWEtNGJjMS04NDkzLTVmODZmYWZhZTU5NDAeFw0yNDExMDYxOTEzMjdaFw0yODExMDYxOTEzMjdaMEwxGzAZBgNVBAoMEkthbmlkbSBSZXBsaWNhdGlvbjEtMCsGA1UEAwwkMmJhODMxNmEtZWJhYS00YmMxLTg0OTMtNWY4NmZhZmFlNTk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEuXp1hNNZerxDQbCh7rAGW6uM0CPECNd3IvbSh7qH34MkO_plwwDVKFbzcTG8HJE2ouIJlJYN8P4wf6qmrRQMAKN0MHIwDAYDVR0TAQH_BAIwADAOBgNVHQ8BAf8EBAMCBaAwHQYDVR0lBBYwFAYIKwYBBQUHAwEGCCsGAQUFBwMCMB0GA1UdDgQWBBTaOaPuXmtLDTJVv--VYBiQr9gHCTAUBgNVHREEDTALgglsb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAIZD_J4LyR7D0kg41GRg_TcRxm5mEVhM6WL9BO3XmfUsAiEA7Wpbkvd0b1e-Sg8AS9jP-CpBpmTnC7oEChkyhUYKyFc=""#.to_string();
245
246 let result = extract_cert(output).unwrap();
247 assert_eq!(
248 result,
249 "MIIB_DCCAaGgAwIBAgIBATAKBggqhkjOPQQDAjBMMRswGQYDVQQKDBJLYW5pZG0gUmVwbGljYXRpb24xLTArBgNVBAMMJDJiYTgzMTZhLWViYWEtNGJjMS04NDkzLTVmODZmYWZhZTU5NDAeFw0yNDExMDYxOTEzMjdaFw0yODExMDYxOTEzMjdaMEwxGzAZBgNVBAoMEkthbmlkbSBSZXBsaWNhdGlvbjEtMCsGA1UEAwwkMmJhODMxNmEtZWJhYS00YmMxLTg0OTMtNWY4NmZhZmFlNTk0MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEuXp1hNNZerxDQbCh7rAGW6uM0CPECNd3IvbSh7qH34MkO_plwwDVKFbzcTG8HJE2ouIJlJYN8P4wf6qmrRQMAKN0MHIwDAYDVR0TAQH_BAIwADAOBgNVHQ8BAf8EBAMCBaAwHQYDVR0lBBYwFAYIKwYBBQUHAwEGCCsGAQUFBwMCMB0GA1UdDgQWBBTaOaPuXmtLDTJVv--VYBiQr9gHCTAUBgNVHREEDTALgglsb2NhbGhvc3QwCgYIKoZIzj0EAwIDSQAwRgIhAIZD_J4LyR7D0kg41GRg_TcRxm5mEVhM6WL9BO3XmfUsAiEA7Wpbkvd0b1e-Sg8AS9jP-CpBpmTnC7oEChkyhUYKyFc="
250 );
251 }
252}