Include signed message when computing Single signatures

Author: Alenar

mithril-common/src/entities/single_signatures.rs

@@ -30,7 +30,7 @@ pub struct SingleSignatures {
 }
 
 impl SingleSignatures {
-    /// SingleSignature factory
+    /// `SingleSignatures` factory
     pub fn new(
         party_id: PartyId,
         signature: ProtocolSingleSignature,
@@ -44,6 +44,21 @@ impl SingleSignatures {
         }
     }
 
+    /// `SingleSignatures` factory including the signed message
+    pub fn new_with_signed_message(
+        party_id: PartyId,
+        signature: ProtocolSingleSignature,
+        won_indexes: Vec<LotteryIndex>,
+        signed_message: String,
+    ) -> SingleSignatures {
+        SingleSignatures {
+            party_id,
+            signature,
+            won_indexes,
+            signed_message: Some(signed_message),
+        }
+    }
+
     /// Convert this [SingleSignatures] to its corresponding [MithrilStm Signature][StmSig].
     pub fn to_protocol_signature(&self) -> StmSig {
         self.signature.clone().into()

mithril-common/src/protocol/single_signer.rs

@@ -23,14 +23,16 @@ impl SingleSigner {
     ///
     /// If no lottery are won None will be returned.
     pub fn sign(&self, message: &ProtocolMessage) -> StdResult<Option<SingleSignatures>> {
-        match self.protocol_signer.sign(message.compute_hash().as_bytes()) {
+        let signed_message = message.compute_hash();
+        match self.protocol_signer.sign(signed_message.as_bytes()) {
             Some(signature) => {
                 let won_indexes = signature.indexes.clone();
 
-                Ok(Some(SingleSignatures::new(
+                Ok(Some(SingleSignatures::new_with_signed_message(
                     self.party_id.to_owned(),
                     signature.into(),
                     won_indexes,
+                    signed_message,
                 )))
             }
             None => Ok(None),
@@ -72,4 +74,32 @@ mod test {
 
         assert!(signature.is_some());
     }
+
+    #[test]
+    fn embed_signed_message_in_issued_signature() {
+        let fixture = MithrilFixtureBuilder::default().with_signers(3).build();
+        let signers = fixture.signers_fixture();
+        let signer = signers.first().unwrap();
+
+        let (single_signer, _) = SignerBuilder::new(
+            &fixture.signers_with_stake(),
+            &fixture.protocol_parameters(),
+        )
+        .unwrap()
+        .build_test_single_signer(
+            signer.signer_with_stake.clone(),
+            signer.kes_secret_key_path(),
+        )
+        .unwrap();
+
+        let message = ProtocolMessage::default();
+        let signature = single_signer
+            .sign(&message)
+            .expect("Single signer should be able to issue single signature");
+
+        assert_eq!(
+            Some(message.compute_hash()),
+            signature.and_then(|s| s.signed_message)
+        );
+    }
 }