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