more changes

Author: BrendanChou

cryptography/src/bls12381/primitives/group.rs

@@ -22,6 +22,8 @@ use blst::{
 };
 use bytes::{Buf, BufMut};
 use commonware_codec::{
+    varint::UInt,
+    EncodeSize,
     Error::{self, Invalid},
     FixedSize, Read, ReadExt, Write,
 };
@@ -347,21 +349,23 @@ impl Share {
 
 impl Write for Share {
     fn write(&self, buf: &mut impl BufMut) {
-        self.index.write(buf);
+        UInt(self.index).write(buf);
         self.private.write(buf);
     }
 }
 
 impl Read for Share {
     fn read_cfg(buf: &mut impl Buf, _: &()) -> Result<Self, Error> {
-        let index = u32::read(buf)?;
+        let index = UInt::read(buf)?.into();
         let private = Private::read(buf)?;
         Ok(Self { index, private })
     }
 }
 
-impl FixedSize for Share {
-    const SIZE: usize = u32::SIZE + Private::SIZE;
+impl EncodeSize for Share {
+    fn encode_size(&self) -> usize {
+        UInt(self.index).encode_size() + self.private.encode_size()
+    }
 }
 
 impl Display for Share {

examples/vrf/src/handlers/wire.rs

@@ -1,5 +1,5 @@
 use bytes::{Buf, BufMut};
-use commonware_codec::{EncodeSize, Error, FixedSize, Read, ReadExt, ReadRangeExt, Write};
+use commonware_codec::{varint::UInt, EncodeSize, Error, Read, ReadExt, ReadRangeExt, Write};
 use commonware_cryptography::bls12381::primitives::{
     group,
     poly::{self, Eval},
@@ -20,22 +20,22 @@ pub struct Dkg<Sig: Array> {
 
 impl<Sig: Array> Write for Dkg<Sig> {
     fn write(&self, buf: &mut impl BufMut) {
-        self.round.write(buf);
+        UInt(self.round).write(buf);
         self.payload.write(buf);
     }
 }
 
 impl<Sig: Array> Read<usize> for Dkg<Sig> {
     fn read_cfg(buf: &mut impl Buf, num_players: &usize) -> Result<Self, Error> {
-        let round = u64::read(buf)?;
+        let round = UInt::read(buf)?.into();
         let payload = Payload::<Sig>::read_cfg(buf, num_players)?;
         Ok(Self { round, payload })
     }
 }
 
 impl<Sig: Array> EncodeSize for Dkg<Sig> {
     fn encode_size(&self) -> usize {
-        self.round.encode_size() + self.payload.encode_size()
+        UInt(self.round).encode_size() + self.payload.encode_size()
     }
 }
 
@@ -122,7 +122,7 @@ impl<Sig: Array> Write for Payload<Sig> {
                 signature,
             } => {
                 buf.put_u8(2);
-                public_key.write(buf);
+                UInt(*public_key).write(buf);
                 signature.write(buf);
             }
             Payload::Commitment {
@@ -163,7 +163,7 @@ impl<Sig: Array> Read<usize> for Payload<Sig> {
                 share: group::Share::read(buf)?,
             },
             2 => Payload::Ack {
-                public_key: u32::read(buf)?,
+                public_key: UInt::read(buf)?.into(),
                 signature: Sig::read(buf)?,
             },
             3 => {
@@ -195,8 +195,11 @@ impl<Sig: Array> EncodeSize for Payload<Sig> {
     fn encode_size(&self) -> usize {
         1 + match self {
             Payload::Start { group } => group.encode_size(),
-            Payload::Share { commitment, .. } => commitment.encode_size() + group::Share::SIZE,
-            Payload::Ack { .. } => u32::SIZE + Sig::SIZE,
+            Payload::Share { commitment, share } => commitment.encode_size() + share.encode_size(),
+            Payload::Ack {
+                public_key,
+                signature,
+            } => UInt(*public_key).encode_size() + signature.encode_size(),
             Payload::Commitment {
                 commitment,
                 acks,
@@ -226,27 +229,29 @@ pub struct Vrf {
 
 impl Write for Vrf {
     fn write(&self, buf: &mut impl BufMut) {
-        self.round.write(buf);
+        UInt(self.round).write(buf);
         self.signature.write(buf);
     }
 }
 
 impl Read for Vrf {
     fn read_cfg(buf: &mut impl Buf, _: &()) -> Result<Self, Error> {
-        let round = u64::read(buf)?;
+        let round = UInt::read(buf)?.into();
         let signature = Eval::<group::Signature>::read(buf)?;
         Ok(Self { round, signature })
     }
 }
 
-impl FixedSize for Vrf {
-    const SIZE: usize = u64::SIZE + Eval::<group::Signature>::SIZE;
+impl EncodeSize for Vrf {
+    fn encode_size(&self) -> usize {
+        UInt(self.round).encode_size() + self.signature.encode_size()
+    }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use commonware_codec::{Decode, DecodeExt, Encode};
+    use commonware_codec::{Decode, DecodeExt, Encode, FixedSize};
     use commonware_cryptography::{
         bls12381::primitives::{
             group::{self, Element},

p2p/src/authenticated/types.rs

@@ -110,20 +110,20 @@ pub struct BitVec {
 
 impl EncodeSize for BitVec {
     fn encode_size(&self) -> usize {
-        self.index.encode_size() + self.bits.encode_size()
+        UInt(self.index).encode_size() + self.bits.encode_size()
     }
 }
 
 impl Write for BitVec {
     fn write(&self, buf: &mut impl BufMut) {
-        self.index.write(buf);
+        UInt(self.index).write(buf);
         self.bits.write(buf);
     }
 }
 
 impl Read<usize> for BitVec {
     fn read_cfg(buf: &mut impl Buf, max_bits: &usize) -> Result<Self, Error> {
-        let index = u64::read(buf)?;
+        let index = UInt::read(buf)?.into();
         let bits = UtilsBitVec::read_cfg(buf, &..=*max_bits)?;
         Ok(Self { index, bits })
     }
@@ -138,7 +138,7 @@ pub struct PeerInfo<C: Verifier> {
     /// The socket address of the peer.
     pub socket: SocketAddr,
 
-    /// The timestamp at which the socket was signed over.
+    /// The timestamp (epoch milliseconds) at which the socket was signed over.
     pub timestamp: u64,
 
     /// The public key of the peer.
@@ -163,7 +163,7 @@ impl<C: Verifier> PeerInfo<C> {
 impl<C: Verifier> EncodeSize for PeerInfo<C> {
     fn encode_size(&self) -> usize {
         self.socket.encode_size()
-            + self.timestamp.encode_size()
+            + UInt(self.timestamp).encode_size()
             + self.public_key.encode_size()
             + self.signature.encode_size()
     }
@@ -172,7 +172,7 @@ impl<C: Verifier> EncodeSize for PeerInfo<C> {
 impl<C: Verifier> Write for PeerInfo<C> {
     fn write(&self, buf: &mut impl BufMut) {
         self.socket.write(buf);
-        self.timestamp.write(buf);
+        UInt(self.timestamp).write(buf);
         self.public_key.write(buf);
         self.signature.write(buf);
     }
@@ -181,7 +181,7 @@ impl<C: Verifier> Write for PeerInfo<C> {
 impl<C: Verifier> Read for PeerInfo<C> {
     fn read_cfg(buf: &mut impl Buf, _: &()) -> Result<Self, Error> {
         let socket = SocketAddr::read(buf)?;
-        let timestamp = u64::read(buf)?;
+        let timestamp = UInt::read(buf)?.into();
         let public_key = C::PublicKey::read(buf)?;
         let signature = C::Signature::read(buf)?;
         Ok(PeerInfo {

stream/src/public_key/handshake.rs

@@ -1,16 +1,25 @@
 use super::x25519;
 use crate::Error;
 use bytes::{Buf, BufMut};
-use commonware_codec::{Encode, Error as CodecError, FixedSize, Read, ReadExt, Write};
+use commonware_codec::{
+    varint::UInt, Encode, EncodeSize, Error as CodecError, Read, ReadExt, Write,
+};
 use commonware_cryptography::Scheme;
 use commonware_runtime::Clock;
 use commonware_utils::SystemTimeExt;
 use std::time::Duration;
 
 /// Handshake information that is signed over by the sender.
 pub struct Info<C: Scheme> {
+    /// The public key of the recipient.
     recipient: C::PublicKey,
+
+    /// The ephemeral public key of the sender.
+    ///
+    /// This is used to derive the shared secret for the encrypted connection.
     ephemeral_public_key: x25519::PublicKey,
+
+    /// Timestamp of the handshake (in epoch milliseconds).
     timestamp: u64,
 }
 
@@ -32,15 +41,15 @@ impl<C: Scheme> Write for Info<C> {
     fn write(&self, buf: &mut impl BufMut) {
         self.recipient.write(buf);
         self.ephemeral_public_key.write(buf);
-        self.timestamp.write(buf);
+        UInt(self.timestamp).write(buf);
     }
 }
 
 impl<C: Scheme> Read for Info<C> {
     fn read_cfg(buf: &mut impl Buf, _: &()) -> Result<Self, CodecError> {
         let recipient = C::PublicKey::read(buf)?;
         let ephemeral_public_key = x25519::PublicKey::read(buf)?;
-        let timestamp = u64::read(buf)?;
+        let timestamp = UInt::read(buf)?.into();
         Ok(Info {
             recipient,
             ephemeral_public_key,
@@ -49,8 +58,12 @@ impl<C: Scheme> Read for Info<C> {
     }
 }
 
-impl<C: Scheme> FixedSize for Info<C> {
-    const SIZE: usize = C::PublicKey::SIZE + x25519::PublicKey::SIZE + u64::SIZE;
+impl<C: Scheme> EncodeSize for Info<C> {
+    fn encode_size(&self) -> usize {
+        self.recipient.encode_size()
+            + self.ephemeral_public_key.encode_size()
+            + UInt(self.timestamp).encode_size()
+    }
 }
 
 // Allows recipient to verify that the sender has the private key
@@ -159,8 +172,10 @@ impl<C: Scheme> Read for Signed<C> {
     }
 }
 
-impl<C: Scheme> FixedSize for Signed<C> {
-    const SIZE: usize = Info::<C>::SIZE + C::PublicKey::SIZE + C::Signature::SIZE;
+impl<C: Scheme> EncodeSize for Signed<C> {
+    fn encode_size(&self) -> usize {
+        self.info.encode_size() + self.signer.encode_size() + self.signature.encode_size()
+    }
 }
 
 #[cfg(test)]