Validate devices

central_backend/src/devices/devices_list.rs

@@ -1,4 +1,5 @@
 use crate::app_config::AppConfig;
+use crate::crypto::pki;
 use crate::devices::device::{Device, DeviceId, DeviceInfo};
 use crate::utils::time_utils::time_secs;
 use openssl::x509::X509Req;
@@ -10,6 +11,10 @@ pub enum DevicesListError {
     EnrollFailedDeviceAlreadyExists,
     #[error("Persist device config failed: the configuration of the device was not found!")]
     PersistFailedDeviceNotFound,
+    #[error("Validated device failed: the device does not exists!")]
+    ValidateDeviceFailedDeviceNotFound,
+    #[error("Validated device failed: the device is already validated!")]
+    ValidateDeviceFailedDeviceAlreadyValidated,
 }
 
 pub struct DevicesList(HashMap<DeviceId, Device>);
@@ -96,6 +101,29 @@ impl DevicesList {
         self.0.clone().into_values().collect()
     }
 
+    /// Validate a device
+    pub fn validate(&mut self, id: &DeviceId) -> anyhow::Result<()> {
+        let dev = self
+            .0
+            .get_mut(id)
+            .ok_or(DevicesListError::ValidateDeviceFailedDeviceNotFound)?;
+
+        if dev.validated {
+            return Err(DevicesListError::ValidateDeviceFailedDeviceAlreadyValidated.into());
+        }
+
+        // Issue certificate
+        let csr = X509Req::from_pem(&std::fs::read(AppConfig::get().device_csr_path(id))?)?;
+        let cert = pki::gen_certificate_for_device(&csr)?;
+        std::fs::write(AppConfig::get().device_cert_path(id), cert)?;
+
+        // Mark device as validated
+        dev.validated = true;
+        self.persist_dev_config(id)?;
+
+        Ok(())
+    }
+
     /// Delete a device
     pub fn delete(&mut self, id: &DeviceId) -> anyhow::Result<()> {
         let crt_path = AppConfig::get().device_cert_path(id);

central_backend/src/energy/energy_actor.rs

@@ -94,6 +94,21 @@ impl Handler<EnrollDevice> for EnergyActor {
     }
 }
 
+/// Validate a device
+#[derive(Message)]
+#[rtype(result = "anyhow::Result<()>")]
+pub struct ValidateDevice(pub DeviceId);
+
+impl Handler<ValidateDevice> for EnergyActor {
+    type Result = anyhow::Result<()>;
+
+    fn handle(&mut self, msg: ValidateDevice, _ctx: &mut Context<Self>) -> Self::Result {
+        log::info!("Requested to validate device {:?}...", &msg.0);
+        self.devices.validate(&msg.0)?;
+        Ok(())
+    }
+}
+
 /// Delete a device
 #[derive(Message)]
 #[rtype(result = "anyhow::Result<()>")]

central_backend/src/server/servers.rs

@@ -139,6 +139,10 @@ pub async fn secure_server(energy_actor: EnergyActorAddr) -> anyhow::Result<()>
                 "/web_api/devices/list_validated",
                 web::get().to(devices_controller::list_validated),
             )
+            .route(
+                "/web_api/device/{id}/validate",
+                web::post().to(devices_controller::validate_device),
+            )
             .route(
                 "/web_api/device/{id}",
                 web::delete().to(devices_controller::delete_device),
@@ -152,6 +156,7 @@ pub async fn secure_server(energy_actor: EnergyActorAddr) -> anyhow::Result<()>
                 "/devices_api/mgmt/enroll",
                 web::post().to(mgmt_controller::enroll),
             )
+        // TODO : check device status
     })
     .bind_openssl(&AppConfig::get().listen_address, builder)?
     .run()

central_backend/src/server/web_api/devices_controller.rs

@@ -33,6 +33,15 @@ pub struct DeviceInPath {
     id: DeviceId,
 }
 
+/// Validate a device
+pub async fn validate_device(actor: WebEnergyActor, id: web::Path<DeviceInPath>) -> HttpResult {
+    actor
+        .send(energy_actor::ValidateDevice(id.id.clone()))
+        .await??;
+
+    Ok(HttpResponse::Accepted().finish())
+}
+
 /// Delete a device
 pub async fn delete_device(actor: WebEnergyActor, id: web::Path<DeviceInPath>) -> HttpResult {
     actor