sphinx: add new NewHopPayload constructor

In this commit, we add a new constructor to abstract away the details of
the hop payload framing from the caller. This new function accepts the
hop data, as well as optional EOB bytes. We'll then map these two pieces
of data into a single hop payload by appending the EOB bytes to the
serialized hop data.

Author: Roasbeef

cmd/main.go

@@ -59,12 +59,21 @@ func parseOnionSpec(spec OnionSpec) (*sphinx.PaymentPath, *btcec.PrivateKey, err
 
 		path[i].NodePub = *pubkey
 
-		path[i].HopPayload.Realm[0] = byte(hop.Realm)
-		path[i].HopPayload.Payload, err = hex.DecodeString(hop.Payload)
+		payload, err := hex.DecodeString(hop.Payload)
 		if err != nil {
-			log.Fatalf("%s is not a valid hex payload %s", hop.Payload, err)
+			log.Fatalf("%s is not a valid hex payload %s",
+				hop.Payload, err)
 		}
 
+		hopPayload, err := sphinx.NewHopPayload(
+			byte(hop.Realm), nil, payload,
+		)
+		if err != nil {
+			log.Fatalf("unable to make payload: %v", err)
+		}
+
+		path[i].HopPayload = hopPayload
+
 		fmt.Fprintf(os.Stderr, "Node %d pubkey %x\n", i, pubkey.SerializeCompressed())
 	}
 	return &path, sessionKey, nil

path.go

@@ -99,18 +99,67 @@ func (hd *HopData) Decode(r io.Reader) error {
 
 // HopPayload is a slice of bytes and associated payload-type that are destined
 // for a specific hop in the PaymentPath. The payload itself is treated as an
-// opaque datafield by the onion router, while the Realm is modified to
+// opaque data field by the onion router, while the Realm is modified to
 // indicate how many hops are to be read by the processing node. The 4 MSB in
 // the realm indicate how many additional hops are to be processed to collect
 // the entire payload.
 type HopPayload struct {
-	Realm [1]byte
+	// realm denotes the "real" of target chain of the next hop. For
+	// bitcoin, this value will be 0x00.
+	realm [RealmByteSize]byte
 
+	// Payload is the raw bytes of the per-hop payload for this hop.
+	// Depending on the realm, this pay be the regular legacy hop data, or
+	// a set of opaque blobs to be parsed by higher layers.
 	Payload []byte
 
+	// HMAC is an HMAC computed over the entire per-hop payload that also
+	// includes the higher-level (optional) associated data bytes.
 	HMAC [HMACSize]byte
 }
 
+// NewHopPayload creates a new hop payload given an optional set of forwarding
+// instructions for a hop, and a set of optional opaque extra onion bytes to
+// drop off at the target hop. If both values are not specified, then an error
+// is returned.
+func NewHopPayload(realm byte, hopData *HopData, eob []byte) (HopPayload, error) {
+
+	var (
+		h HopPayload
+		b bytes.Buffer
+	)
+
+	// We can't proceed if neither the hop data or the EOB has been
+	// specified by the caller.
+	if hopData == nil && len(eob) == 0 {
+		return h, fmt.Errorf("either hop data or eob must " +
+			"be specified")
+	}
+
+	// If the hop data is specified, then we'll write that now, as it
+	// should proceed the EOB portion of the payload.
+	if hopData != nil {
+		if err := hopData.Encode(&b); err != nil {
+			return h, nil
+		}
+	}
+
+	// Finally, we'll write out the EOB portion to the same buffer to
+	// ensure it comes after mandatory hop payload.
+	if _, err := b.Write(eob); err != nil {
+		return h, nil
+	}
+
+	h.realm = [RealmByteSize]byte{realm}
+	h.Payload = b.Bytes()
+
+	return h, nil
+}
+
+// Realm returns the context specific representation of the realm for a hop.
+func (hp *HopPayload) Realm() byte {
+	return hp.realm[0] & RealmMaskBytes
+}
 // NumFrames returns the total number of frames it'll take to pack the target
 // HopPayload into a Sphinx packet.
 func (hp *HopPayload) NumFrames() int {

path_test.go

@@ -21,14 +21,17 @@ func TestHopPayloadSizes(t *testing.T) {
 	}
 
 	for _, tt := range tests {
-		hp := HopPayload{
-			Realm:   [1]byte{1},
-			Payload: bytes.Repeat([]byte{0x00}, tt.size),
+		hp, err := NewHopPayload(
+			1, nil, bytes.Repeat([]byte{0x00}, tt.size),
+		)
+		if err != nil {
+			t.Fatalf("unable to make hop payload: %v", err)
 		}
 
 		actual := hp.NumFrames()
 		if actual != tt.expected {
-			t.Errorf("Wrong number of hops returned: expected %d, actual %d", tt.expected, actual)
+			t.Errorf("wrong number of hops returned: expected "+
+				"%d, actual %d", tt.expected, actual)
 		}
 
 		hp.CalculateRealm()

sphinx.go

@@ -268,7 +268,6 @@ func NewOnionPacket(paymentPath *PaymentPath, sessionKey *btcec.PrivateKey,
 		packet := append(mixHeader[:], assocData...)
 		nextHmac = calcMac(muKey, packet)
 
-		hopDataBuf.Reset()
 		hopPayloadBuf.Reset()
 	}
 

sphinx_test.go

@@ -120,23 +120,31 @@ func newTestVarSizeRoute(numHops int, extraPayloadSize []int) ([]*Router, *Payme
 
 		copy(hopData.NextAddress[:], bytes.Repeat([]byte{byte(i)}, 8))
 
+		var extraData []byte
+
+		// If we were told to increase the payload with some extra data
+		// do it now.
+		if extraPayloadSize[i] > 0 {
+			extraData = bytes.Repeat([]byte{'A'}, extraPayloadSize[i])
+		}
+
+		hopPayload, err := NewHopPayload(0, &hopData, extraData)
+		if err != nil {
+			return nil, nil, nil, nil, fmt.Errorf("unable to "+
+				"create new hop payload: %v", err)
+		}
+
 		route[i] = OnionHop{
-			NodePub: *nodes[i].onionKey.PubKey(),
-			HopData: hopData,
+			NodePub:    *nodes[i].onionKey.PubKey(),
+			HopPayload: hopPayload,
 		}
 	}
 
-	// If we were told to increase the payload with some extra data do it
-	// now:
 	for i := 0; i < route.TrueRouteLength(); i++ {
-		if extraPayloadSize[i] > 0 {
-			extra := bytes.Repeat([]byte{'A'}, extraPayloadSize[i])
-			route[i].HopPayload.Payload = append(route[i].HopPayload.Payload, extra...)
-		}
 	}
 
 	// Generate a forwarding message to route to the final node via the
-	// generated intermdiates nodes above.  Destination should be Hash160,
+	// generated intermediate nodes above.  Destination should be Hash160,
 	// adding padding so parsing still works.
 	sessionKey, _ := btcec.PrivKeyFromBytes(
 		btcec.S256(), bytes.Repeat([]byte{'A'}, 32),
@@ -172,18 +180,22 @@ func TestBolt4Packet(t *testing.T) {
 		}
 
 		hopData := HopData{
-			Realm:         [1]byte{0x00},
 			ForwardAmount: uint64(i),
 			OutgoingCltv:  uint32(i),
 		}
 		copy(hopData.NextAddress[:], bytes.Repeat([]byte{byte(i)}, 8))
 		hopsData = append(hopsData, hopData)
 
+		hopPayload, err := NewHopPayload(0, &hopData, nil)
+		if err != nil {
+			t.Fatalf("unable to make hop payload: %v", err)
+		}
+
 		pubKey.Curve = nil
 
 		route[i] = OnionHop{
-			NodePub: *pubKey,
-			HopData: hopData,
+			NodePub:    *pubKey,
+			HopPayload: hopPayload,
 		}
 	}
 
@@ -548,7 +560,7 @@ func TestMultiFrameEncodeDecode(t *testing.T) {
 				t.Logf("Processing at hop: %v \n", i)
 				onionPacket, err := hop.ProcessOnionPacket(fwdMsg, nil, uint32(i)+1)
 				if err != nil {
-					t.Fatalf("Node %v was unable to process the "+
+					t.Fatalf("node %v was unable to process the "+
 						"forwarding message: %v", i, err)
 				}