[cryptography/certificate] make namespace a part of the scheme

consensus/fuzz/fuzz_targets/simplex_bls12381_multisig_minpk.rs

@@ -15,8 +15,12 @@ impl Simplex for SimplexBls12381MultisigMinPk {
     type Scheme = bls12381_multisig::Scheme<Ed25519PublicKey, MinPk>;
     type Elector = RoundRobin;
 
-    fn fixture(context: &mut deterministic::Context, n: u32) -> Fixture<Self::Scheme> {
-        bls12381_multisig::fixture::<MinPk, _>(context, n)
+    fn fixture(
+        context: &mut deterministic::Context,
+        namespace: &[u8],
+        n: u32,
+    ) -> Fixture<Self::Scheme> {
+        bls12381_multisig::fixture::<MinPk, _>(context, namespace, n)
     }
 }
 

consensus/fuzz/fuzz_targets/simplex_bls12381_multisig_minsig.rs

@@ -15,8 +15,12 @@ impl Simplex for SimplexBls12381MultisigMinSig {
     type Scheme = bls12381_multisig::Scheme<Ed25519PublicKey, MinSig>;
     type Elector = RoundRobin;
 
-    fn fixture(context: &mut deterministic::Context, n: u32) -> Fixture<Self::Scheme> {
-        bls12381_multisig::fixture::<MinSig, _>(context, n)
+    fn fixture(
+        context: &mut deterministic::Context,
+        namespace: &[u8],
+        n: u32,
+    ) -> Fixture<Self::Scheme> {
+        bls12381_multisig::fixture::<MinSig, _>(context, namespace, n)
     }
 }
 

consensus/fuzz/fuzz_targets/simplex_bls12381_threshold_minpk.rs

@@ -15,8 +15,12 @@ impl Simplex for SimplexBls12381MinPk {
     type Scheme = bls12381_threshold::Scheme<Ed25519PublicKey, MinPk>;
     type Elector = Random;
 
-    fn fixture(context: &mut deterministic::Context, n: u32) -> Fixture<Self::Scheme> {
-        bls12381_threshold::fixture::<MinPk, _>(context, n)
+    fn fixture(
+        context: &mut deterministic::Context,
+        namespace: &[u8],
+        n: u32,
+    ) -> Fixture<Self::Scheme> {
+        bls12381_threshold::fixture::<MinPk, _>(context, namespace, n)
     }
 }
 

consensus/fuzz/fuzz_targets/simplex_bls12381_threshold_minsig.rs

@@ -15,8 +15,12 @@ impl Simplex for SimplexBls12381MinSig {
     type Scheme = bls12381_threshold::Scheme<Ed25519PublicKey, MinSig>;
     type Elector = Random;
 
-    fn fixture(context: &mut deterministic::Context, n: u32) -> Fixture<Self::Scheme> {
-        bls12381_threshold::fixture::<MinSig, _>(context, n)
+    fn fixture(
+        context: &mut deterministic::Context,
+        namespace: &[u8],
+        n: u32,
+    ) -> Fixture<Self::Scheme> {
+        bls12381_threshold::fixture::<MinSig, _>(context, namespace, n)
     }
 }
 

consensus/fuzz/fuzz_targets/simplex_ed25519.rs

@@ -12,8 +12,12 @@ impl Simplex for SimplexEd25519 {
     type Scheme = ed25519::Scheme;
     type Elector = RoundRobin;
 
-    fn fixture(context: &mut deterministic::Context, n: u32) -> Fixture<Self::Scheme> {
-        ed25519::fixture(context, n)
+    fn fixture(
+        context: &mut deterministic::Context,
+        namespace: &[u8],
+        n: u32,
+    ) -> Fixture<Self::Scheme> {
+        ed25519::fixture(context, namespace, n)
     }
 }
 

consensus/fuzz/fuzz_targets/simplex_secp256r1.rs

@@ -14,8 +14,12 @@ impl Simplex for SimplexSecp256r1 {
     type Scheme = secp256r1::Scheme<Ed25519PublicKey>;
     type Elector = RoundRobin;
 
-    fn fixture(context: &mut deterministic::Context, n: u32) -> Fixture<Self::Scheme> {
-        secp256r1::fixture(context, n)
+    fn fixture(
+        context: &mut deterministic::Context,
+        namespace: &[u8],
+        n: u32,
+    ) -> Fixture<Self::Scheme> {
+        secp256r1::fixture(context, namespace, n)
     }
 }
 

consensus/fuzz/src/disrupter.rs

@@ -35,7 +35,6 @@ pub struct Disrupter<E: Clock + Spawner + CryptoRngCore, S: Scheme<Sha256Digest>
     validator: PublicKey,
     scheme: S,
     participants: Set<PublicKey>,
-    namespace: Vec<u8>,
     fuzz_input: FuzzInput,
     last_vote: u64,
     last_finalized: u64,
@@ -52,7 +51,6 @@ where
         validator: PublicKey,
         scheme: S,
         participants: Set<PublicKey>,
-        namespace: Vec<u8>,
         fuzz_input: FuzzInput,
     ) -> Self {
         Self {
@@ -64,7 +62,6 @@ where
             validator,
             scheme,
             participants,
-            namespace,
             fuzz_input,
         }
     }
@@ -222,7 +219,7 @@ where
                     let _ = sender.send(Recipients::All, mutated.into(), true).await;
                 } else {
                     let proposal = self.mutate_proposal(&notarize.proposal);
-                    if let Some(v) = Notarize::sign(&self.scheme, &self.namespace, proposal) {
+                    if let Some(v) = Notarize::sign(&self.scheme, proposal) {
                         let msg = Vote::<S, Sha256Digest>::Notarize(v).encode().into();
                         let _ = sender.send(Recipients::All, msg, true).await;
                     }
@@ -234,7 +231,7 @@ where
                     let _ = sender.send(Recipients::All, mutated.into(), true).await;
                 } else {
                     let proposal = self.mutate_proposal(&finalize.proposal);
-                    if let Some(v) = Finalize::sign(&self.scheme, &self.namespace, proposal) {
+                    if let Some(v) = Finalize::sign(&self.scheme, proposal) {
                         let msg = Vote::<S, Sha256Digest>::Finalize(v).encode().into();
                         let _ = sender.send(Recipients::All, msg, true).await;
                     }
@@ -247,9 +244,7 @@ where
                 } else {
                     let v = self.random_view(self.last_vote);
                     let round = Round::new(Epoch::new(EPOCH), View::new(v));
-                    if let Some(v) =
-                        Nullify::<S>::sign::<Sha256Digest>(&self.scheme, &self.namespace, round)
-                    {
+                    if let Some(v) = Nullify::<S>::sign::<Sha256Digest>(&self.scheme, round) {
                         let msg = Vote::<S, Sha256Digest>::Nullify(v).encode().into();
                         let _ = sender.send(Recipients::All, msg, true).await;
                     }
@@ -338,13 +333,13 @@ where
 
         match self.message() {
             Message::Notarize => {
-                if let Some(vote) = Notarize::sign(&self.scheme, &self.namespace, proposal) {
+                if let Some(vote) = Notarize::sign(&self.scheme, proposal) {
                     let msg = Vote::<S, Sha256Digest>::Notarize(vote).encode().into();
                     let _ = sender.send(Recipients::All, msg, true).await;
                 }
             }
             Message::Finalize => {
-                if let Some(vote) = Finalize::sign(&self.scheme, &self.namespace, proposal) {
+                if let Some(vote) = Finalize::sign(&self.scheme, proposal) {
                     let msg = Vote::<S, Sha256Digest>::Finalize(vote).encode().into();
                     let _ = sender.send(Recipients::All, msg, true).await;
                 }
@@ -354,9 +349,7 @@ where
                     Epoch::new(EPOCH),
                     View::new(self.random_view(self.last_vote)),
                 );
-                if let Some(vote) =
-                    Nullify::<S>::sign::<Sha256Digest>(&self.scheme, &self.namespace, round)
-                {
+                if let Some(vote) = Nullify::<S>::sign::<Sha256Digest>(&self.scheme, round) {
                     let msg = Vote::<S, Sha256Digest>::Nullify(vote).encode().into();
                     let _ = sender.send(Recipients::All, msg, true).await;
                 }

consensus/fuzz/src/lib.rs

@@ -55,7 +55,11 @@ where
 {
     type Scheme: Scheme<Sha256Digest, PublicKey = Ed25519PublicKey>;
     type Elector: Elector<Self::Scheme>;
-    fn fixture(context: &mut deterministic::Context, n: u32) -> Fixture<Self::Scheme>;
+    fn fixture(
+        context: &mut deterministic::Context,
+        namespace: &[u8],
+        n: u32,
+    ) -> Fixture<Self::Scheme>;
 }
 
 #[derive(Debug, Clone)]
@@ -143,7 +147,6 @@ impl Arbitrary<'_> for FuzzInput {
 fn run<P: Simplex>(input: FuzzInput) {
     let (n, _, f) = input.configuration;
     let containers = input.containers;
-    let namespace = NAMESPACE.to_vec();
     let cfg = deterministic::Config::new().with_seed(input.seed);
     let executor = deterministic::Runner::new(cfg);
 
@@ -163,7 +166,7 @@ fn run<P: Simplex>(input: FuzzInput) {
             schemes,
             verifier: _,
             ..
-        } = P::fixture(&mut context, n);
+        } = P::fixture(&mut context, NAMESPACE, n);
 
         let mut registrations = register(&mut oracle, &participants).await;
 
@@ -197,7 +200,6 @@ fn run<P: Simplex>(input: FuzzInput) {
                     .clone()
                     .try_into()
                     .expect("public keys are unique"),
-                namespace.clone(),
                 input.clone(),
             );
             disrupter.start(vote_network, certificate_network);
@@ -208,7 +210,6 @@ fn run<P: Simplex>(input: FuzzInput) {
             let context = context.with_label(&format!("validator_{validator}"));
             let elector = P::Elector::default();
             let reporter_cfg = reporter::Config {
-                namespace: namespace.clone(),
                 participants: participants
                     .clone()
                     .try_into()
@@ -245,7 +246,6 @@ fn run<P: Simplex>(input: FuzzInput) {
                 partition: validator.to_string(),
                 mailbox_size: 1024,
                 epoch: Epoch::new(EPOCH),
-                namespace: namespace.clone(),
                 leader_timeout: Duration::from_secs(1),
                 notarization_timeout: Duration::from_secs(2),
                 nullify_retry: Duration::from_secs(10),

consensus/src/aggregation/config.rs

@@ -39,10 +39,6 @@ pub struct Config<
     /// Blocking is handled by [commonware_p2p].
     pub blocker: B,
 
-    /// The application namespace used to sign over different types of messages.
-    /// Used to prevent replay attacks on other applications.
-    pub namespace: Vec<u8>,
-
     /// Whether acks are sent as priority.
     pub priority_acks: bool,
 

consensus/src/aggregation/engine.rs

@@ -86,10 +86,6 @@ pub struct Engine<
     reporter: Z,
     blocker: B,
 
-    // ---------- Namespace Constants ----------
-    /// The namespace signatures.
-    namespace: Vec<u8>,
-
     // Pruning
     /// A tuple representing the epochs to keep in memory.
     /// The first element is the number of old epochs to keep.
@@ -176,7 +172,6 @@ impl<
             monitor: cfg.monitor,
             provider: cfg.provider,
             blocker: cfg.blocker,
-            namespace: cfg.namespace,
             epoch_bounds: cfg.epoch_bounds,
             window: cfg.window.into(),
             activity_timeout: cfg.activity_timeout,
@@ -666,7 +661,7 @@ impl<
         }
 
         // Validate signature
-        if !ack.verify(&mut self.context, &*scheme, &self.namespace) {
+        if !ack.verify(&mut self.context, &*scheme) {
             return Err(Error::InvalidAckSignature);
         }
 
@@ -703,8 +698,7 @@ impl<
 
         // Sign the item
         let item = Item { index, digest };
-        let ack = Ack::sign(&*scheme, &self.namespace, self.epoch, item)
-            .ok_or(Error::NotSigner(self.epoch))?;
+        let ack = Ack::sign(&*scheme, self.epoch, item).ok_or(Error::NotSigner(self.epoch))?;
 
         // Journal the ack
         self.record(Activity::Ack(ack.clone())).await;

consensus/src/aggregation/mocks/reporter.rs

@@ -30,9 +30,6 @@ pub struct Reporter<R: CryptoRngCore, S: Scheme, D: Digest> {
     // RNG used for signature verification with scheme.
     rng: R,
 
-    // Application namespace
-    namespace: Vec<u8>,
-
     // Signing scheme for verification
     scheme: S,
 
@@ -58,13 +55,12 @@ where
     S: scheme::Scheme<D>,
     D: Digest,
 {
-    pub fn new(rng: R, namespace: &[u8], scheme: S) -> (Self, Mailbox<S, D>) {
+    pub fn new(rng: R, scheme: S) -> (Self, Mailbox<S, D>) {
         let (sender, receiver) = mpsc::channel(1024);
         (
             Self {
                 mailbox: receiver,
                 rng,
-                namespace: namespace.to_vec(),
                 scheme,
                 acks: HashSet::new(),
                 digests: BTreeMap::new(),
@@ -81,7 +77,7 @@ where
             match msg {
                 Message::Ack(ack) => {
                     // Verify properly constructed (not needed in production)
-                    assert!(ack.verify(&mut self.rng, &self.scheme, &self.namespace));
+                    assert!(ack.verify(&mut self.rng, &self.scheme));
 
                     // Test encoding/decoding
                     let encoded = ack.encode();
@@ -95,7 +91,7 @@ where
                 }
                 Message::Certified(certificate) => {
                     // Verify certificate
-                    assert!(certificate.verify(&mut self.rng, &self.scheme, &self.namespace));
+                    assert!(certificate.verify(&mut self.rng, &self.scheme));
 
                     // Test encoding/decoding
                     let encoded = certificate.encode();