sphinx: remove HopData from OnionHop, expose left over EOB from payload

In this commit, we remove the HopData field from the OnionHop struct as
it's no longer needed since we can obtain the HopData via the HopData()
method of the HopPayload struct. Additinoally, we also now return the
set of unused payload bytes after the HopData encoding, we call these
the EOB or extra onion blobs.

With this distinction we now provide the caller of ProcessOnionPacket
with the forwarding instructions, then the left over EOB bytes. These
EOB bytes will then be interpreted using a TLV format or any other
arbitrary framing system.

Author: Roasbeef

bench_test.go

@@ -28,15 +28,19 @@ func BenchmarkPathPacketConstruction(b *testing.B) {
 		}
 
 		hopData := HopData{
-			Realm:         [1]byte{0x00},
 			ForwardAmount: uint64(i),
 			OutgoingCltv:  uint32(i),
 		}
 		copy(hopData.NextAddress[:], bytes.Repeat([]byte{byte(i)}, 8))
 
+		hopPayload, err := NewHopPayload(0, &hopData, nil)
+		if err != nil {
+			b.Fatalf("unable to create new hop payload: %v", err)
+		}
+
 		route[i] = OnionHop{
-			NodePub: *privKey.PubKey(),
-			HopData: hopData,
+			NodePub:    *privKey.PubKey(),
+			HopPayload: hopPayload,
 		}
 	}
 

path.go

@@ -257,39 +257,30 @@ func (hp *HopPayload) Decode(r io.Reader) error {
 
 // HopData attempts to extract a set of forwarding instructions from the target
 // HopPayload. If the realm isn't what we expect, then an error is returned.
-func (hp *HopPayload) HopData() (*HopData, error) {
+// This method also returns the left over EOB that remain after the hop data
+// has been parsed. Callers may want to map this blob into something more
+// concrete.
+func (hp *HopPayload) HopData() (*HopData, []byte, error) {
 	// If this isn't the "base" realm, then we can't extract the expected
 	// hop payload structure from the payload.
-	if hp.Realm[0]&RealmMaskBytes != 0x00 {
-		return nil, fmt.Errorf("payload is not a HopData payload, "+
-			"realm=%d", hp.Realm[0])
+	if hp.Realm() != 0x00 {
+		return nil, nil, fmt.Errorf("payload is not a HopData "+
+			"payload, realm=%d", hp.Realm())
 	}
 
 	// Now that we know the payload has the structure we expect, we'll
 	// decode the payload into the HopData.
-	hd := HopData{
-		Realm: [1]byte{hp.Realm[0] & RealmMaskBytes},
-		HMAC:  hp.HMAC,
+	var hd HopData
+	payloadReader := bytes.NewBuffer(hp.Payload)
+	if err := hd.Decode(payloadReader); err != nil {
+		return &hd, nil, nil
 	}
 
-	r := bytes.NewBuffer(hp.Payload)
-	if _, err := io.ReadFull(r, hd.NextAddress[:]); err != nil {
-		return nil, err
-	}
-
-	if err := binary.Read(r, binary.BigEndian, &hd.ForwardAmount); err != nil {
-		return nil, err
-	}
-
-	if err := binary.Read(r, binary.BigEndian, &hd.OutgoingCltv); err != nil {
-		return nil, err
-	}
+	// What's left over in the buffer that wasn't parsed as part of the
+	// forwarding instructions is our lingering EOB.
+	eob := payloadReader.Bytes()
 
-	if _, err := io.ReadFull(r, hd.ExtraBytes[:]); err != nil {
-		return nil, err
-	}
-
-	return &hd, nil
+	return &hd, eob, nil
 }
 
 // NumMaxHops is the maximum path length. This should be set to an estimate of
@@ -318,10 +309,6 @@ type OnionHop struct {
 	// internal packet to the next hop.
 	NodePub btcec.PublicKey
 
-	// HopData are the plaintext routing instructions that should be
-	// delivered to this hop.
-	HopData HopData
-
 	// HopPayload is the opaque payload provided to this node. If the
 	// HopData above is specified, then it'll be packed into this payload.
 	HopPayload HopPayload

sphinx.go

@@ -443,17 +443,19 @@ type ProcessedPacket struct {
 	// MoreHops.
 	ForwardingInstructions *HopData
 
-	// RawPayload is the raw (plaintext) payload that was passed to the
-	// processing node in the onion packet. It provides accessors to get
-	// the parsed and interpreted data.
-	RawPayload HopPayload
+	// ExtraOnionBlob is the raw EOB payload unpacked by this hop. This is
+	// the portion of the payload _without_ the prefixed forwarding
+	// instructions.
+	ExtraOnionBlob []byte
 
 	// NextPacket is the onion packet that should be forwarded to the next
 	// hop as denoted by the ForwardingInstructions field.
 	//
 	// NOTE: This field will only be populated iff the above Action is
 	// MoreHops.
 	NextPacket *OnionPacket
+
+	rawPayload HopPayload
 }
 
 // Router is an onion router within the Sphinx network. The router is capable
@@ -649,7 +651,7 @@ func processOnionPacket(onionPkt *OnionPacket, sharedSecret *Hash256,
 		action = ExitNode
 	}
 
-	hopData, err := outerHopPayload.HopData()
+	hopData, eob, err := outerHopPayload.HopData()
 	if err != nil {
 		return nil, err
 	}
@@ -660,8 +662,9 @@ func processOnionPacket(onionPkt *OnionPacket, sharedSecret *Hash256,
 	return &ProcessedPacket{
 		Action:                 action,
 		ForwardingInstructions: hopData,
-		RawPayload:             *outerHopPayload,
+		ExtraOnionBlob:         eob,
 		NextPacket:             innerPkt,
+		rawPayload:             *outerHopPayload,
 	}, nil
 }
 

sphinx_test.go

@@ -113,11 +113,9 @@ func newTestVarSizeRoute(numHops int, extraPayloadSize []int) ([]*Router, *Payme
 	)
 	for i := 0; i < len(nodes); i++ {
 		hopData := HopData{
-			Realm:         [1]byte{0x00},
 			ForwardAmount: uint64(i),
 			OutgoingCltv:  uint32(i),
 		}
-
 		copy(hopData.NextAddress[:], bytes.Repeat([]byte{byte(i)}, 8))
 
 		var extraData []byte
@@ -157,7 +155,13 @@ func newTestVarSizeRoute(numHops int, extraPayloadSize []int) ([]*Router, *Payme
 
 	var hopsData []HopData
 	for i := 0; i < len(nodes); i++ {
-		hopsData = append(hopsData, route[i].HopData)
+		hopData, _, err := route[i].HopPayload.HopData()
+		if err != nil {
+			return nil, nil, nil, nil, fmt.Errorf("unable to "+
+				"gen hop data: %v", err)
+		}
+
+		hopsData = append(hopsData, *hopData)
 	}
 
 	return nodes, &route, &hopsData, fwdMsg, nil
@@ -564,22 +568,22 @@ func TestMultiFrameEncodeDecode(t *testing.T) {
 						"forwarding message: %v", i, err)
 				}
 
-				// Check that the framecount matches what we expect
-				frameCount := onionPacket.RawPayload.NumFrames()
+				// Check that the frame count matches what we expect
+				frameCount := onionPacket.rawPayload.NumFrames()
 				if tt.expectedFrames[i] != frameCount {
-					t.Fatalf("Incorrect number of payload frames: expected %d, got %d",
-						tt.expectedFrames[i],
-						frameCount,
+					t.Fatalf("incorrect number of payload "+
+						"frames: expected %d, got %d",
+						tt.expectedFrames[i], frameCount,
 					)
 				}
 
 				// Check that the payload contents are identical
 				expected := path[i].HopPayload
 				if !bytes.Equal(path[i].HopPayload.Payload, expected.Payload) {
-					t.Fatalf("Processing error, hop-payload parsed incorrectly."+
-						" expected %x, got %x",
+					t.Fatalf("processing error, hop-payload "+
+						"parsed incorrectly.  expected %x, got %x",
 						expected.Payload,
-						onionPacket.RawPayload.Payload)
+						onionPacket.rawPayload.Payload)
 				}
 
 				fwdMsg = onionPacket.NextPacket