Remove empty ephemeral keys

common/client-core/src/client/base_client/storage/mod.rs

@@ -4,6 +4,8 @@
 // TODO: combine those more closely. Perhaps into a single underlying store.
 // Like for persistent, on-disk, storage, what's the point of having 3 different databases?
 
+use rand::rngs::OsRng;
+
 use crate::client::key_manager::persistence::{InMemEphemeralKeys, KeyStore};
 use crate::client::replies::reply_storage;
 use crate::client::replies::reply_storage::ReplyStorageBackend;
@@ -63,17 +65,21 @@ pub trait MixnetClientStorage {
     fn gateway_details_store(&self) -> &Self::GatewaysDetailsStore;
 }
 
-#[derive(Default)]
 pub struct Ephemeral {
     key_store: InMemEphemeralKeys,
     reply_store: reply_storage::Empty,
     credential_store: EphemeralCredentialStorage,
     gateway_details_store: InMemGatewaysDetails,
 }
 
-impl Ephemeral {
-    pub fn new() -> Self {
-        Default::default()
+impl Default for Ephemeral {
+    fn default() -> Self {
+        Ephemeral {
+            key_store: InMemEphemeralKeys::new(&mut OsRng),
+            reply_store: Default::default(),
+            credential_store: Default::default(),
+            gateway_details_store: Default::default(),
+        }
     }
 }
 

common/client-core/src/client/key_manager/persistence.rs

@@ -3,6 +3,7 @@
 
 use crate::client::key_manager::ClientKeys;
 use async_trait::async_trait;
+use rand::{CryptoRng, RngCore};
 use std::error::Error;
 use tokio::sync::Mutex;
 
@@ -193,9 +194,19 @@ impl KeyStore for OnDiskKeys {
     }
 }
 
-#[derive(Default)]
 pub struct InMemEphemeralKeys {
-    keys: Mutex<Option<ClientKeys>>,
+    keys: Mutex<ClientKeys>,
+}
+
+impl InMemEphemeralKeys {
+    pub fn new<R>(rng: &mut R) -> Self
+    where
+        R: RngCore + CryptoRng,
+    {
+        InMemEphemeralKeys {
+            keys: Mutex::new(ClientKeys::generate_new(rng)),
+        }
+    }
 }
 
 #[derive(Debug, thiserror::Error)]
@@ -208,11 +219,11 @@ impl KeyStore for InMemEphemeralKeys {
     type StorageError = EphemeralKeysError;
 
     async fn load_keys(&self) -> Result<ClientKeys, Self::StorageError> {
-        self.keys.lock().await.clone().ok_or(EphemeralKeysError)
+        Ok(self.keys.lock().await.clone())
     }
 
     async fn store_keys(&self, keys: &ClientKeys) -> Result<(), Self::StorageError> {
-        *self.keys.lock().await = Some(keys.clone());
+        *self.keys.lock().await = keys.clone();
         Ok(())
     }
 }