WIP: needs refactoring

Author: steveej

Cargo.lock

@@ -61,10 +61,21 @@ pub struct Settings {
     pub admin: Admin,
 }
 
+/// Returns the default derivation path per config version.
+pub const fn default_derivation_path(config: ConfigDiscriminants) -> u32 {
+    match config {
+        // TODO: what should these be?
+        ConfigDiscriminants::V1 => 2,
+        ConfigDiscriminants::V2 => 2,
+        ConfigDiscriminants::V3 => 2,
+    }
+}
+
+#[allow(clippy::large_enum_variant)]
 #[cfg_attr(test, derive(Clone, PartialEq))]
 #[derive(Debug, Deserialize, Serialize, EnumDiscriminants)]
 #[strum_discriminants(
-    derive(VariantNames, EnumString, strum::Display),
+    derive(VariantNames, EnumString, strum::Display, Default),
     strum(ascii_case_insensitive)
 )]
 pub enum Config {
@@ -86,6 +97,7 @@ pub enum Config {
         settings: Settings,
     },
     #[serde(rename = "v3")]
+    #[strum_discriminants(default)]
     V3 {
         /// This is the Device Seed Bundle as a base64 string which is compatible with lair-keystore >=v0.0.8
         /// And is encoded with a password that will be needed to be used to decrypt it

core/src/config.rs

@@ -1,19 +1,13 @@
 use ed25519_dalek::SigningKey;
-use failure::bail;
+use failure::{bail, ResultExt};
 use log::debug;
 
 use crate::{
-    config::Seed,
+    config::{self, ConfigDiscriminants, Seed},
     types::{SeedExplorerError, SeedExplorerResult},
 };
 use hc_seed_bundle::{LockedSeedCipher, UnlockedSeedBundle};
 
-// TODO: what should this be?
-pub const DEFAULT_DERIVATION_PATH_V2: u32 = 3;
-
-// TODO: what should this be?
-pub const DEFAULT_DERIVATION_PATH_V3: u32 = 3;
-
 pub fn get_seed_from_bundle(device_bundle: &UnlockedSeedBundle) -> Result<Seed, failure::Error> {
     let mut seed = Seed::default();
 
@@ -53,7 +47,9 @@ pub async fn generate_device_bundle(
         .await
         .unwrap();
 
-    let derivation_path = maybe_derivation_path.unwrap_or(DEFAULT_DERIVATION_PATH_V3);
+    let derivation_path = maybe_derivation_path.unwrap_or(config::default_derivation_path(
+        ConfigDiscriminants::default(),
+    ));
 
     let device_bundle = master.derive(derivation_path).await.unwrap();
 
@@ -69,21 +65,25 @@ pub async fn generate_device_bundle(
 }
 
 /// Unlock the given device bundle with the given password.
-pub async fn get_seed_from_locked_device_bundle(
+async fn _get_seed_from_locked_device_bundle(
     locked_device_bundle: &[u8],
     passphrase: &str,
 ) -> Result<Seed, failure::Error> {
     let passphrase = sodoken::BufRead::from(passphrase.as_bytes());
     let unlocked_bundle =
         match hc_seed_bundle::UnlockedSeedBundle::from_locked(locked_device_bundle)
-            .await?
+            .await
+            .context("getting seed from locked device bundle")?
             .remove(0)
         {
-            hc_seed_bundle::LockedSeedCipher::PwHash(cipher) => cipher.unlock(passphrase).await,
+            hc_seed_bundle::LockedSeedCipher::PwHash(cipher) => {
+                cipher.unlock(passphrase).await.context("unlocking cipher")
+            }
             oth => bail!("unexpected cipher: {:?}", oth),
         }?;
 
-    let seed = get_seed_from_bundle(&unlocked_bundle)?;
+    let seed =
+        get_seed_from_bundle(&unlocked_bundle).context("getting seed from unlocked bundle")?;
 
     Ok(seed)
 }
@@ -167,4 +167,19 @@ pub(crate) mod tests {
             ))
             .unwrap_err();
     }
+
+    #[tokio::test(flavor = "multi_thread")]
+    async fn extract_seed_from_locked_succeeds() {
+        let encoded_device_bundle = generate_base64().await;
+        let device_bundle =
+            base64::decode_config(&encoded_device_bundle, base64::URL_SAFE_NO_PAD).unwrap();
+
+        let a = _get_seed_from_locked_device_bundle(&device_bundle, PASSPHRASE)
+            .await
+            .unwrap();
+
+        let b = unlock(&encoded_device_bundle, PASSPHRASE).await.unwrap();
+
+        assert_eq!(a, *b.as_bytes());
+    }
 }

core/src/utils.rs

@@ -20,3 +20,8 @@ sha2 = "0.8"
 clap = { version = "4.5.16", features = ["derive"] }
 base64 = { workspace = true }
 tokio = { workspace = true }
+
+[dev-dependencies]
+assert_cmd = "2.0"
+predicates = "3.1"
+once_cell = "1.19"

gen-cli/Cargo.toml

@@ -1,8 +1,6 @@
 use hpos_config_core::{
     config::{ConfigDiscriminants, Seed},
-    public_key,
-    utils::get_seed_from_locked_device_bundle,
-    Config,
+    public_key, Config,
 };
 
 use clap::Parser;
@@ -61,7 +59,7 @@ struct ClapArgs {
 
     #[arg(
         long,
-        default_value_t = ConfigDiscriminants::V3,
+        default_value_t = ConfigDiscriminants::default(),
         ignore_case = true,
         help = "Version specifier for the emitted config"
     )]
@@ -77,14 +75,16 @@ async fn main() -> Result<(), Error> {
     let derivation_path = if let Some(derivation_path) = args.derivation_path {
         derivation_path
     } else {
-        hpos_config_core::utils::DEFAULT_DERIVATION_PATH_V2
+        hpos_config_core::config::default_derivation_path(ConfigDiscriminants::default())
     };
 
     // TODO: don't hardcode this
     let passphrase = "pass";
 
     let device_bundle = if let Some(device_bundle) = args.device_bundle {
-        seed = get_seed_from_locked_device_bundle(device_bundle.as_bytes(), passphrase).await?;
+        seed = hpos_config_core::utils::unlock(&device_bundle, passphrase)
+            .await?
+            .to_scalar_bytes();
 
         device_bundle
     } else {