Implement ProtocolKey for Genesis Secret Key

Author: Damien LACHAUME / PALO-IT

mithril-aggregator/src/commands/genesis_command.rs

@@ -1,8 +1,8 @@
-use anyhow::{anyhow, Context};
+use anyhow::Context;
 use clap::{Parser, Subcommand};
 use config::{builder::DefaultState, ConfigBuilder};
 use mithril_common::{
-    crypto_helper::{key_decode_hex, ProtocolGenesisSigner},
+    crypto_helper::{ProtocolGenesisSecretKey, ProtocolGenesisSigner},
     entities::HexEncodedGenesisSecretKey,
     StdResult,
 };
@@ -175,8 +175,8 @@ impl BootstrapGenesisSubCommand {
         let genesis_tools = GenesisTools::from_dependencies(dependencies)
             .await
             .with_context(|| "genesis-tools: initialization error")?;
-        let genesis_secret_key = key_decode_hex(&self.genesis_secret_key)
-            .map_err(|e| anyhow!(e).context("json hex decode of genesis secret key failure"))?;
+        let genesis_secret_key = ProtocolGenesisSecretKey::from_json_hex(&self.genesis_secret_key)
+            .with_context(|| "json hex decode of genesis secret key failure")?;
         let genesis_signer = ProtocolGenesisSigner::from_secret_key(genesis_secret_key);
         genesis_tools
             .bootstrap_test_genesis_certificate(genesis_signer)

mithril-aggregator/src/tools/genesis.rs

@@ -1,4 +1,4 @@
-use anyhow::anyhow;
+use anyhow::{anyhow, Context};
 use std::{fs::File, io::prelude::*, io::Write, path::Path, sync::Arc};
 use tokio::sync::RwLock;
 
@@ -139,8 +139,10 @@ impl GenesisTools {
         let mut genesis_secret_key_serialized = String::new();
         genesis_secret_key_file.read_to_string(&mut genesis_secret_key_serialized)?;
 
-        let genesis_secret_key = key_decode_hex(genesis_secret_key_serialized.trim())
-            .map_err(|e| anyhow!(e).context("Genesis secret key decode error"))?;
+        let genesis_secret_key = genesis_secret_key_serialized
+            .trim()
+            .try_into()
+            .with_context(|| "Genesis secret key decode error")?;
         let genesis_signer = ProtocolGenesisSigner::from_secret_key(genesis_secret_key);
 
         let mut to_sign_payload_file = File::open(to_sign_payload_path).unwrap();

mithril-common/src/crypto_helper/genesis.rs

@@ -6,10 +6,7 @@ use serde::{Deserialize, Serialize};
 use std::{fs::File, io::Write, path::Path};
 use thiserror::Error;
 
-use super::{
-    key_encode_hex, ProtocolGenesisSecretKey, ProtocolGenesisSignature,
-    ProtocolGenesisVerificationKey,
-};
+use super::{ProtocolGenesisSecretKey, ProtocolGenesisSignature, ProtocolGenesisVerificationKey};
 
 #[derive(Error, Debug)]
 /// [ProtocolGenesisSigner] and [ProtocolGenesisVerifier] related errors.
@@ -33,8 +30,8 @@ impl ProtocolGenesisSigner {
     where
         R: CryptoRng + RngCore,
     {
-        let secret_key = ProtocolGenesisSecretKey::generate(&mut rng);
-        Self::from_secret_key(secret_key)
+        let secret_key = ed25519_dalek::SecretKey::generate(&mut rng);
+        Self::from_secret_key(secret_key.into())
     }
 
     /// ProtocolGenesisSigner deterministic
@@ -56,7 +53,7 @@ impl ProtocolGenesisSigner {
 
     /// Create a an expanded secret key
     fn create_expanded_secret_key(&self) -> ExpandedSecretKey {
-        ExpandedSecretKey::from(&self.secret_key)
+        ExpandedSecretKey::from(&*self.secret_key)
     }
 
     /// Create a ProtocolGenesisVerificationKey
@@ -85,11 +82,7 @@ impl ProtocolGenesisSigner {
     #[doc(hidden)]
     pub fn export_to_file(&self, secret_key_path: &Path) -> StdResult<()> {
         let mut genesis_secret_key_file = File::create(secret_key_path)?;
-        genesis_secret_key_file.write_all(
-            key_encode_hex(self.secret_key.as_bytes())
-                .unwrap()
-                .as_bytes(),
-        )?;
+        genesis_secret_key_file.write_all(self.secret_key.to_json_hex().unwrap().as_bytes())?;
 
         Ok(())
     }
@@ -125,7 +118,6 @@ impl ProtocolGenesisVerifier {
 
 #[cfg(test)]
 mod tests {
-    use super::super::codec::{key_decode_hex, key_encode_hex};
     use super::*;
 
     #[test]
@@ -145,11 +137,11 @@ mod tests {
 
         println!(
             "Deterministic Genesis Verification Key={}",
-            key_encode_hex(genesis_verifier.verification_key.as_bytes()).unwrap()
+            genesis_verifier.verification_key.to_json_hex().unwrap()
         );
         println!(
             "Deterministic Genesis Secret Key=={}",
-            key_encode_hex(genesis_signer.secret_key.as_bytes()).unwrap()
+            genesis_signer.secret_key.to_json_hex().unwrap()
         );
     }
 
@@ -160,25 +152,23 @@ mod tests {
 
         println!(
             "Non Deterministic Genesis Verification Key={}",
-            key_encode_hex(genesis_verifier.verification_key.as_bytes()).unwrap()
+            genesis_verifier.verification_key.to_json_hex().unwrap()
         );
         println!(
             "Non Deterministic Genesis Secret Key=={}",
-            key_encode_hex(genesis_signer.secret_key.as_bytes()).unwrap()
+            genesis_signer.secret_key.to_json_hex().unwrap()
         );
     }
 
     #[test]
     fn test_codec_genesis_keypair() {
         let genesis_signer = ProtocolGenesisSigner::create_deterministic_genesis_signer();
         let genesis_verifier = genesis_signer.create_genesis_verifier();
-        let secret_key_encoded = key_encode_hex(genesis_signer.secret_key.as_bytes()).unwrap();
-        let verification_key_encoded =
-            key_encode_hex(genesis_verifier.verification_key.as_bytes()).unwrap();
-        let secret_key_decoded: ProtocolGenesisSecretKey =
-            key_decode_hex(&secret_key_encoded).unwrap();
+        let secret_key_encoded = genesis_signer.secret_key.to_json_hex().unwrap();
+        let verification_key_encoded = genesis_verifier.verification_key.to_json_hex().unwrap();
+        let secret_key_decoded: ProtocolGenesisSecretKey = secret_key_encoded.try_into().unwrap();
         let verification_key_decoded: ProtocolGenesisVerificationKey =
-            key_decode_hex(&verification_key_encoded).unwrap();
+            verification_key_encoded.try_into().unwrap();
         let genesis_signer_decoded = ProtocolGenesisSigner::from_secret_key(secret_key_decoded);
         let genesis_verifier_decoded =
             ProtocolGenesisVerifier::from_verification_key(verification_key_decoded);

mithril-common/src/crypto_helper/types/alias.rs

@@ -10,7 +10,6 @@ use mithril_stm::{
 };
 
 use blake2::{digest::consts::U32, Blake2b};
-use ed25519_dalek;
 
 /// A protocol version
 pub type ProtocolVersion<'a> = &'a str;
@@ -51,9 +50,6 @@ pub type ProtocolClosedKeyRegistration = ClosedKeyReg<D>;
 /// Alias of [MithrilStm:StmAggrVerificationKey](struct@mithril_stm::stm::StmAggrVerificationKey).
 pub type ProtocolAggregateVerificationKey = StmAggrVerificationKey<D>;
 
-/// Alias of [Ed25519:SecretKey](https://docs.rs/ed25519-dalek/latest/ed25519_dalek/struct.SecretKey.html).
-pub type ProtocolGenesisSecretKey = ed25519_dalek::SecretKey;
-
 // Error alias
 /// Alias of a wrapper of [MithrilCommon:ProtocolRegistrationErrorWrapper](enum@ProtocolRegistrationErrorWrapper).
 pub type ProtocolRegistrationError = ProtocolRegistrationErrorWrapper;

mithril-common/src/crypto_helper/types/wrappers.rs

@@ -29,6 +29,9 @@ pub type ProtocolOpCert = ProtocolKey<OpCert>;
 /// Alias of [Ed25519:PublicKey](https://docs.rs/ed25519-dalek/latest/ed25519_dalek/struct.PublicKey.html).
 pub type ProtocolGenesisVerificationKey = ProtocolKey<ed25519_dalek::PublicKey>;
 
+/// Alias of [Ed25519:SecretKey](https://docs.rs/ed25519-dalek/latest/ed25519_dalek/struct.SecretKey.html).
+pub type ProtocolGenesisSecretKey = ProtocolKey<ed25519_dalek::SecretKey>;
+
 impl ProtocolGenesisSignature {
     /// Create an instance from a bytes hex representation
     pub fn from_bytes_hex(hex_string: &str) -> StdResult<Self> {
@@ -73,6 +76,6 @@ impl ProtocolKeyCodec<ed25519_dalek::Signature> for ed25519_dalek::Signature {
 }
 
 impl_codec_and_type_conversions_for_protocol_key!(
-    json_hex_codec => StmVerificationKeyPoP, Sum6KesSig, StmSig, StmAggrSig<D>, OpCert, ed25519_dalek::PublicKey
+    json_hex_codec => StmVerificationKeyPoP, Sum6KesSig, StmSig, StmAggrSig<D>, OpCert, ed25519_dalek::PublicKey, ed25519_dalek::SecretKey
 );
 impl_codec_and_type_conversions_for_protocol_key!(no_default_codec => ed25519_dalek::Signature);