start implementing signature verification for add and revoke

Author: sebasti810

crates/common/src/hashchain.rs

@@ -1,8 +1,9 @@
 use anyhow::{anyhow, bail, Result};
+use ed25519_dalek::{Signature, Verifier, VerifyingKey};
 use jmt::KeyHash;
 use serde::{Deserialize, Serialize};
 use std::{
-    collections::{HashMap, HashSet},
+    collections::HashSet,
     ops::{Deref, DerefMut},
 };
 
@@ -165,24 +166,73 @@ impl Hashchain {
     }
 
     // TODO: Obviously, this needs to be authenticated by an existing key.
-    pub fn add(&mut self, value: PublicKey, signature: SignatureBundle) -> Result<Digest> {
-        let operation = Operation::AddKey(KeyOperationArgs {
+    pub fn add(&mut self, value: PublicKey, signature_bundle: SignatureBundle) -> Result<Digest> {
+        self.perform_operation(Operation::AddKey, value, signature_bundle)
+    }
+
+    pub fn revoke(
+        &mut self,
+        value: PublicKey,
+        signature_bundle: SignatureBundle,
+    ) -> Result<Digest> {
+        self.perform_operation(Operation::RevokeKey, value, signature_bundle)
+    }
+
+    fn perform_operation(
+        &mut self,
+        operation_type: fn(KeyOperationArgs) -> Operation,
+        value: PublicKey,
+        signature_bundle: SignatureBundle,
+    ) -> Result<Digest> {
+        let signing_key = self.get_key_at_index(signature_bundle.key_idx as usize)?;
+
+        if self.is_key_revoked(signing_key.clone()) {
+            bail!("The signing key is revoked");
+        }
+
+        let operation_to_sign = operation_type(KeyOperationArgs {
             id: self.id.clone(),
-            value,
-            signature,
+            value: value.clone(),
+            signature: SignatureBundle {
+                key_idx: signature_bundle.key_idx,
+                signature: Vec::new(),
+            },
         });
-        self.push(operation)
-    }
 
-    pub fn revoke(&mut self, value: PublicKey, signature: SignatureBundle) -> Result<Digest> {
-        let operation = Operation::RevokeKey(KeyOperationArgs {
+        let message = bincode::serialize(&operation_to_sign)?;
+        self.verify_signature(
+            &signing_key,
+            &message,
+            signature_bundle.signature.as_slice(),
+        )?;
+
+        let operation = operation_type(KeyOperationArgs {
             id: self.id.clone(),
             value,
-            signature,
+            signature: signature_bundle,
         });
         self.push(operation)
     }
 
+    fn verify_signature(
+        &self,
+        public_key: &PublicKey,
+        message: &[u8],
+        signature: &[u8],
+    ) -> Result<()> {
+        match public_key {
+            PublicKey::Ed25519(key_bytes) => {
+                let verifying_key = VerifyingKey::from_bytes(key_bytes.as_slice().try_into()?)?;
+                let signature = Signature::from_slice(signature)?;
+                verifying_key
+                    .verify(message, &signature)
+                    .map_err(|e| anyhow::anyhow!("Signature verification failed: {}", e))
+            }
+            // pot. cases for other key types in the future here
+            _ => bail!("Unsupported key type for verification"),
+        }
+    }
+
     pub fn get_keyhash(&self) -> KeyHash {
         KeyHash::with::<Hasher>(self.id.clone())
     }

crates/common/src/test_utils.rs

@@ -1,7 +1,7 @@
 use crate::{
     hashchain::{Hashchain, HashchainEntry},
     operation::{KeyOperationArgs, Operation, PublicKey, SignatureBundle},
-    tree::{hash, InsertProof, KeyDirectoryTree, SnarkableTree, UpdateProof},
+    tree::{hash, Digest, InsertProof, KeyDirectoryTree, SnarkableTree, UpdateProof},
 };
 use anyhow::{anyhow, Result};
 use ed25519_dalek::{Signer, SigningKey};
@@ -132,18 +132,14 @@ pub fn create_mock_hashchain(id: &str) -> Hashchain {
     hc
 }
 
-pub fn create_mock_chain_entry(signing_key: &SigningKey) -> HashchainEntry {
+pub fn create_mock_chain_entry(signing_key: &SigningKey, previous_hash: Digest) -> HashchainEntry {
     let operation = Operation::AddKey(KeyOperationArgs {
         id: "test_id".to_string(),
         value: PublicKey::Ed25519(signing_key.verifying_key().to_bytes().to_vec()),
         signature: create_mock_signature(signing_key, b"test_id"),
     });
 
-    HashchainEntry {
-        hash: hash(b"test_hash"),
-        previous_hash: hash(b"test_previous_hash"),
-        operation,
-    }
+    HashchainEntry::new(operation, previous_hash)
 }
 
 pub fn create_add_key_operation_with_test_value(id: &str, signing_key: &SigningKey) -> Operation {