chore(signed-envelope): utilize protobuf-serialization (#2650)

Author: vladopajic

libp2p/extended_peer_record.nim

@@ -138,7 +138,7 @@ proc isValid*(xpr: SignedExtendedPeerRecord): bool =
     if not svc.isValid():
       return false
   let encoded = xpr.encode()
-  if encoded.isErr or encoded.get().len == 0 or encoded.get().len > MaxXPRSize:
+  if encoded.len == 0 or encoded.len > MaxXPRSize:
     return false
   true
 

libp2p/protocols/connectivity/relay/relay.nim

@@ -84,7 +84,7 @@ proc createReserveResponse(
     rsrv = Reservation(
       expire: Opt.some(expireUnix),
       addrs: r.switch.peerInfo.addrs.mapIt(?it.concat(ma).orErr(CryptoError.KeyError)),
-      svoucher: Opt.some(?sv.encode),
+      svoucher: Opt.some(sv.encode),
     )
     msg = HopMessage(
       msgType: Opt.some(HopMessageType.Status),

libp2p/protocols/identify.nim

@@ -93,8 +93,7 @@ proc makeIdentifyMsg(
   ## Optionally populate signedPeerRecord field.
   ## See https://github.com/libp2p/go-libp2p/blob/ddf96ce1cfa9e19564feb9bd3e8269958bbc0aba/p2p/protocol/identify/pb/identify.proto for reference.
   if sign:
-    pi.signedPeerRecord.envelope.encode().withValue(value):
-      spr = Opt.some(value)
+    spr = Opt.some(pi.signedPeerRecord.envelope.encode())
 
   IdentifyMsg(
     publicKey: Opt.some(pi.publicKey),

libp2p/protocols/pubsub/gossipsub/behavior.nim

@@ -123,7 +123,7 @@ proc peerExchangeList*(g: GossipSub, topic: string): seq[PeerInfoMsg] =
       peerId: x.peerId,
       signedPeerRecord:
         if x.peerId in sprBook:
-          sprBook[x.peerId].encode().get(default(seq[byte]))
+          sprBook[x.peerId].encode()
         else:
           default(seq[byte]),
     )

libp2p/protocols/rendezvous/rendezvous.nim

@@ -327,8 +327,7 @@ proc advertise*[E](
     info "Can't create the signed peer record", error = error
     return
 
-  let pBuff = signedPeerRecord.encode().valueOr:
-    raise newException(AdvertiseError, "Wrong Custom Peer Record")
+  let pBuff = signedPeerRecord.encode()
   await rdv.advertise(ns, ttl, peers, Opt.some(pBuff))
 
 proc advertise*[E](
@@ -364,8 +363,7 @@ method advertise*(
   if rdv.switch.isNil:
     # I don't like this, but adding this as i don't understand why we have a constructor without switch as arg
     raise newException(AdvertiseError, "Rendezvous not setup with a switch")
-  let sprBuff = rdv.switch.peerInfo.signedPeerRecord.encode().valueOr:
-    raise newException(AdvertiseError, "Wrong Signed Peer Record")
+  let sprBuff = rdv.switch.peerInfo.signedPeerRecord.encode()
   await rdv.advertise(ns, lttl, rdv.peers, sprBuff)
 
 proc requestLocally*[E](rdv: GenericRendezVous[E], ns: string): seq[E] =

libp2p/protocols/service_discovery.nim

@@ -23,10 +23,7 @@ proc refreshSelfSignedPeerRecord(
     error "Failed to create signed extended peer record", error
     return
 
-  let encodedSR = extPeerRecord.encode().valueOr:
-    error "Failed to encode signed peer record", error
-    return
-
+  let encodedSR = extPeerRecord.encode()
   let key = disco.switch.peerInfo.peerId.toKey()
 
   debug "Publishing Signed XPR", xpr = $extPeerRecord

libp2p/protocols/service_discovery/advertiser.nim

@@ -43,10 +43,7 @@ proc getAdvertBytes(disco: ServiceDiscovery, explicit: Opt[seq[byte]]): Opt[seq[
   let extRecord = disco.record().valueOr:
     error "failed to create extended peer record", error
     return Opt.none(seq[byte])
-  let bytes = extRecord.encode().valueOr:
-    error "failed to encode advertisement", error
-    return Opt.none(seq[byte])
-  Opt.some(bytes)
+  Opt.some(extRecord.encode())
 
 proc advertiseToRegistrar*(
   disco: ServiceDiscovery,

libp2p/protocols/service_discovery/types.nim

@@ -140,10 +140,7 @@ proc encode*(ads: seq[Advertisement], fReturn: int): seq[seq[byte]] {.raises: []
   for ad in ads:
     if adBytes.len >= fReturn:
       break
-    let encoded = ad.encode().valueOr:
-      error "failed to encode advertisement", error
-      continue
-    adBytes.add(encoded)
+    adBytes.add(ad.encode())
   adBytes
 
 proc hashServiceId*(serviceStr: string): ServiceId =

libp2p/signed_envelope.nim

@@ -7,7 +7,8 @@
 
 import std/sugar
 import pkg/stew/byteutils, pkg/results
-import multicodec, crypto/crypto, protobuf/minprotobuf, vbuffer
+import multicodec, crypto/crypto, vbuffer
+import protobuf_serialization
 
 export crypto
 
@@ -18,46 +19,21 @@ type
     EnvelopeInvalidSignature
     EnvelopeWrongType
 
-  Envelope* = object
-    publicKey*: PublicKey
-    domain*: string
-    payloadType*: seq[byte]
-    payload: seq[byte]
-    signature*: Signature
+  Envelope* {.proto3.} = object
+    publicKey* {.fieldNumber: 1, ext.}: PublicKey
+    payloadType* {.fieldNumber: 2.}: seq[byte]
+    payload {.fieldNumber: 3.}: seq[byte]
+    signature* {.fieldNumber: 5, ext.}: Signature
 
-proc mapProtobufError(e: ProtoError): EnvelopeError =
-  case e
-  of RequiredFieldMissing: EnvelopeFieldMissing
-  else: EnvelopeInvalidProtobuf
-
-proc getSignatureBuffer(e: Envelope): seq[byte] =
+proc getSignatureBuffer(e: Envelope, domain: string): seq[byte] =
   var buffer = initVBuffer()
 
-  let domainBytes = e.domain.toBytes()
-  buffer.writeSeq(domainBytes)
+  buffer.writeSeq(domain.toBytes())
   buffer.writeSeq(e.payloadType)
   buffer.writeSeq(e.payload)
 
   buffer.buffer
 
-proc decode*(
-    T: typedesc[Envelope], buf: sink seq[byte], domain: string
-): Result[Envelope, EnvelopeError] =
-  let pb = initProtoBuffer(move(buf))
-  var envelope = Envelope()
-
-  envelope.domain = domain
-  ?pb.getRequiredField(1, envelope.publicKey).mapErr(mapProtobufError)
-  discard ?pb.getField(2, envelope.payloadType).mapErr(mapProtobufError)
-  ?pb.getRequiredField(3, envelope.payload).mapErr(mapProtobufError)
-  ?pb.getRequiredField(5, envelope.signature).mapErr(mapProtobufError)
-
-  if envelope.signature.verify(envelope.getSignatureBuffer(), envelope.publicKey) ==
-      false:
-    err(EnvelopeInvalidSignature)
-  else:
-    ok(envelope)
-
 proc init*(
     T: typedesc[Envelope],
     privateKey: PrivateKey,
@@ -67,49 +43,43 @@ proc init*(
 ): Result[Envelope, CryptoError] =
   var envelope = Envelope(
     publicKey: ?privateKey.getPublicKey(),
-    domain: domain,
     payloadType: move(payloadType),
     payload: move(payload),
   )
 
-  envelope.signature = ?privateKey.sign(envelope.getSignatureBuffer())
+  envelope.signature = ?privateKey.sign(envelope.getSignatureBuffer(domain))
 
   ok(envelope)
 
-proc encode*(env: Envelope): Result[seq[byte], CryptoError] =
-  var pb = initProtoBuffer()
+proc verify*(envelope: Envelope, domain: string): bool =
+  envelope.signature.verify(envelope.getSignatureBuffer(domain), envelope.publicKey)
+
+proc encode*(envelope: Envelope): seq[byte] =
+  Protobuf.encode(envelope)
 
-  try:
-    pb.write(1, env.publicKey)
-    pb.write(2, env.payloadType)
-    pb.write(3, env.payload)
-    pb.write(5, env.signature)
-  except ResultError[CryptoError] as exc:
-    return err(exc.error)
+proc decode*(
+    _: type Envelope, buf: seq[byte], domain: string
+): Result[Envelope, EnvelopeError] =
+  let envelope =
+    try:
+      Protobuf.decode(buf, Envelope)
+    except SerializationError:
+      return err(EnvelopeInvalidProtobuf)
 
-  pb.finish()
-  ok(pb.buffer)
+  if envelope.publicKey.getBytes().isErr:
+    return err(EnvelopeFieldMissing)
 
-proc payload*(env: Envelope): seq[byte] =
+  if envelope.signature.data.len == 0:
+    return err(EnvelopeFieldMissing)
+
+  if not envelope.verify(domain):
+    return err(EnvelopeInvalidSignature)
+
+  ok(envelope)
+
+proc payload*(envelope: Envelope): seq[byte] =
   # Payload is readonly
-  env.payload
-
-proc getField*(
-    pb: ProtoBuffer, field: int, value: var Envelope, domain: string
-): ProtoResult[bool] =
-  var buffer: seq[byte]
-  let res = ?pb.getField(field, buffer)
-  if not (res):
-    ok(false)
-  else:
-    value = Envelope.decode(move(buffer), domain).valueOr:
-      return err(ProtoError.IncorrectBlob)
-    ok(true)
-
-proc write*(pb: var ProtoBuffer, field: int, env: Envelope): Result[void, CryptoError] =
-  let e = ?env.encode()
-  pb.write(field, e)
-  ok()
+  envelope.payload
 
 type SignedPayload*[T] = object
   # T needs to have .encode(), .decode(), .payloadType(), .payloadDomain()
@@ -126,31 +96,20 @@ proc init*[T](
 
   ok(SignedPayload[T](data: data, envelope: envelope))
 
-proc getField*[T](
-    pb: ProtoBuffer, field: int, value: var SignedPayload[T]
-): ProtoResult[bool] =
-  if not ?getField(pb, field, value.envelope, T.payloadDomain):
-    ok(false)
-  else:
-    mixin decode
-    value.data = ?T.decode(value.envelope.payload).mapErr(x => ProtoError.IncorrectBlob)
-    ok(true)
-
 proc decode*[T](
     _: typedesc[SignedPayload[T]], envelope: Envelope
 ): Result[SignedPayload[T], EnvelopeError] =
   mixin decode
 
-  if envelope.domain != T.payloadDomain:
+  if envelope.payloadType != T.payloadType:
     return err(EnvelopeWrongType)
+  if not envelope.verify(T.payloadDomain):
+    return err(EnvelopeInvalidSignature)
 
   let
     data = ?T.decode(envelope.payload).mapErr(x => EnvelopeInvalidProtobuf)
     signedPayload = SignedPayload[T](envelope: envelope, data: data)
 
-  if envelope.payloadType != T.payloadType:
-    return err(EnvelopeWrongType)
-
   when compiles(?signedPayload.checkValid()):
     ?signedPayload.checkValid()
 
@@ -162,5 +121,5 @@ proc decode*[T](
   let envelope = ?Envelope.decode(move(buffer), T.payloadDomain)
   SignedPayload[T].decode(envelope)
 
-proc encode*[T](msg: SignedPayload[T]): Result[seq[byte], CryptoError] =
+proc encode*[T](msg: SignedPayload[T]): seq[byte] =
   msg.envelope.encode()

tests/libp2p/discovery/test_rendezvous.nim

@@ -113,8 +113,7 @@ proc advertise*(
     rdv.switch.peerInfo.privateKey, customPeerRecord
   ).valueOr:
     raise newException(AdvertiseError, "Failed to sign Custom Peer Record")
-  let sprBuff = se.encode().valueOr:
-    raise newException(AdvertiseError, "Wrong Signed Peer Record")
+  let sprBuff = se.encode()
   await rdv.advertise(namespace, rdv.config.minDuration, rdv.peers, sprBuff)
 
 suite "RendezVous":