rename fat to attributable [squash]

Author: joostjager

fat_error_crypto.go renamed to attributable_error_crypto.go

@@ -3,17 +3,14 @@ package sphinx
 import (
 	"crypto/hmac"
 	"crypto/sha256"
-	"encoding/binary"
 )
 
-var byteOrder = binary.BigEndian
-
-type FatErrorStructure struct {
-	MaxHops        int
-	MaxPayloadSize int
+type AttributableErrorStructure struct {
+	HopCount        int
+	FixedPayloadLen int
 }
 
-type fatErrorBase struct {
+type attributableErrorBase struct {
 	maxHops             int
 	totalHmacs          int
 	allHmacsLen         int
@@ -23,34 +20,40 @@ type fatErrorBase struct {
 	payloadDataLen      int
 }
 
-func newFatErrorBase(structure *FatErrorStructure) fatErrorBase {
+func newAttributableErrorBase(
+	structure *AttributableErrorStructure) attributableErrorBase {
+
 	var (
-		payloadDataLen = structure.MaxPayloadSize
+		payloadDataLen = structure.FixedPayloadLen
 
-		// payloadLen is the size of the per-node payload. It consists of a 1-byte
-		// payload type followed by the payload data.
+		// payloadLen is the size of the per-node payload. It consists of a
+		// 1-byte payload type followed by the payload data.
 		payloadLen = 1 + payloadDataLen
 
-		totalHmacs          = (structure.MaxHops * (structure.MaxHops + 1)) / 2
+		totalHmacs = (structure.HopCount *
+			(structure.HopCount + 1)) / 2
+
 		allHmacsLen         = totalHmacs * sha256.Size
-		allPayloadsLen      = payloadLen * structure.MaxHops
+		allPayloadsLen      = payloadLen * structure.HopCount
 		hmacsAndPayloadsLen = allHmacsLen + allPayloadsLen
 	)
 
-	return fatErrorBase{
+	return attributableErrorBase{
 		totalHmacs:          totalHmacs,
 		allHmacsLen:         allHmacsLen,
 		hmacsAndPayloadsLen: hmacsAndPayloadsLen,
 		allPayloadsLen:      allPayloadsLen,
-		maxHops:             structure.MaxHops,
+		maxHops:             structure.HopCount,
 		payloadLen:          payloadLen,
 		payloadDataLen:      payloadDataLen,
 	}
 }
 
 // getMsgComponents splits a complete failure message into its components
 // without re-allocating memory.
-func (o *fatErrorBase) getMsgComponents(data []byte) ([]byte, []byte, []byte) {
+func (o *attributableErrorBase) getMsgComponents(data []byte) ([]byte, []byte,
+	[]byte) {
+
 	payloads := data[len(data)-o.hmacsAndPayloadsLen : len(data)-o.allHmacsLen]
 	hmacs := data[len(data)-o.allHmacsLen:]
 	message := data[:len(data)-o.hmacsAndPayloadsLen]
@@ -61,8 +64,8 @@ func (o *fatErrorBase) getMsgComponents(data []byte) ([]byte, []byte, []byte) {
 // calculateHmac calculates an hmac given a shared secret and a presumed
 // position in the path. Position is expressed as the distance to the error
 // source. The error source itself is at position 0.
-func (o *fatErrorBase) calculateHmac(sharedSecret Hash256, position int,
-	message, payloads, hmacs []byte) []byte {
+func (o *attributableErrorBase) calculateHmac(sharedSecret Hash256,
+	position int, message, payloads, hmacs []byte) []byte {
 
 	umKey := generateKey("um", &sharedSecret)
 	hash := hmac.New(sha256.New, umKey[:])

fat_error_crypto_test.go renamed to attributable_error_crypto_test.go

@@ -11,14 +11,14 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-var fatErrorTestStructure = &FatErrorStructure{
-	MaxHops:        27,
-	MaxPayloadSize: 8,
+var attributableErrorTestStructure = &AttributableErrorStructure{
+	HopCount:        27,
+	FixedPayloadLen: 8,
 }
 
-// TestFatOnionFailure checks the ability of sender of payment to decode the
-// obfuscated onion error.
-func TestFatOnionFailure(t *testing.T) {
+// TestAttributableOnionFailure checks the ability of sender of payment to
+// decode the obfuscated onion error.
+func TestAttributableOnionFailure(t *testing.T) {
 	t.Parallel()
 
 	// Create numHops random sphinx paymentPath.
@@ -33,8 +33,8 @@ func TestFatOnionFailure(t *testing.T) {
 	require.NoError(t, err)
 
 	// Emulate creation of the obfuscator on node where error have occurred.
-	obfuscator := NewOnionFatErrorEncrypter(
-		sharedSecrets[len(errorPath)-1], fatErrorTestStructure,
+	obfuscator := NewOnionAttributableErrorEncrypter(
+		sharedSecrets[len(errorPath)-1], attributableErrorTestStructure,
 	)
 
 	// Emulate the situation when last hop creates the onion failure
@@ -50,8 +50,8 @@ func TestFatOnionFailure(t *testing.T) {
 	for i := len(errorPath) - 2; i >= 0; i-- {
 		// Emulate creation of the obfuscator on forwarding node which
 		// propagates the onion failure.
-		obfuscator = NewOnionFatErrorEncrypter(
-			sharedSecrets[i], fatErrorTestStructure,
+		obfuscator = NewOnionAttributableErrorEncrypter(
+			sharedSecrets[i], attributableErrorTestStructure,
 		)
 
 		intermediatePayload := [8]byte{byte(100 + i)}
@@ -64,10 +64,10 @@ func TestFatOnionFailure(t *testing.T) {
 	}
 
 	// Emulate creation of the deobfuscator on the receiving onion error side.
-	deobfuscator := NewOnionFatErrorDecrypter(&Circuit{
+	deobfuscator := NewOnionAttributableErrorDecrypter(&Circuit{
 		SessionKey:  sessionKey,
 		PaymentPath: paymentPath,
-	}, fatErrorTestStructure)
+	}, attributableErrorTestStructure)
 
 	// Emulate that sender node receive the failure message and trying to
 	// unwrap it, by applying obfuscation and checking the hmac.
@@ -103,22 +103,24 @@ func TestOnionFailureCorruption(t *testing.T) {
 	require.NoError(t, err)
 
 	// Emulate creation of the obfuscator on node where error have occurred.
-	obfuscator := NewOnionFatErrorEncrypter(
-		sharedSecrets[len(errorPath)-1], fatErrorTestStructure,
+	obfuscator := NewOnionAttributableErrorEncrypter(
+		sharedSecrets[len(errorPath)-1], attributableErrorTestStructure,
 	)
 
 	// Emulate the situation when last hop creates the onion failure
 	// message and send it back.
 	payload := [8]byte{1}
-	obfuscatedData, err := obfuscator.EncryptError(true, failureData, payload[:])
+	obfuscatedData, err := obfuscator.EncryptError(
+		true, failureData, payload[:],
+	)
 	require.NoError(t, err)
 
 	// Emulate that failure message is backward obfuscated on every hop.
 	for i := len(errorPath) - 2; i >= 0; i-- {
 		// Emulate creation of the obfuscator on forwarding node which
 		// propagates the onion failure.
-		obfuscator = NewOnionFatErrorEncrypter(
-			sharedSecrets[i], fatErrorTestStructure,
+		obfuscator = NewOnionAttributableErrorEncrypter(
+			sharedSecrets[i], attributableErrorTestStructure,
 		)
 
 		payload := [8]byte{byte(100 + i)}
@@ -135,10 +137,10 @@ func TestOnionFailureCorruption(t *testing.T) {
 	}
 
 	// Emulate creation of the deobfuscator on the receiving onion error side.
-	deobfuscator := NewOnionFatErrorDecrypter(&Circuit{
+	deobfuscator := NewOnionAttributableErrorDecrypter(&Circuit{
 		SessionKey:  sessionKey,
 		PaymentPath: paymentPath,
-	}, fatErrorTestStructure)
+	}, attributableErrorTestStructure)
 
 	// Emulate that sender node receive the failure message and trying to
 	// unwrap it, by applying obfuscation and checking the hmac.
@@ -163,10 +165,10 @@ type specVector struct {
 
 // TestOnionFailureSpecVector checks that onion error corresponds to the
 // specification.
-func TestFatOnionFailureSpecVector(t *testing.T) {
+func TestAttributableFailureSpecVector(t *testing.T) {
 	t.Parallel()
 
-	vectorBytes, err := os.ReadFile("testdata/fat_error.json")
+	vectorBytes, err := os.ReadFile("testdata/attributable_error.json")
 	require.NoError(t, err)
 
 	var vector specVector
@@ -191,8 +193,9 @@ func TestFatOnionFailureSpecVector(t *testing.T) {
 		expectedSharedSecret, err := hex.DecodeString(test.SharedSecret)
 		require.NoError(t, err)
 
-		obfuscator := NewOnionFatErrorEncrypter(
-			sharedSecrets[len(sharedSecrets)-1-i], fatErrorTestStructure,
+		obfuscator := NewOnionAttributableErrorEncrypter(
+			sharedSecrets[len(sharedSecrets)-1-i],
+			attributableErrorTestStructure,
 		)
 
 		require.Equal(t, expectedSharedSecret, obfuscator.sharedSecret[:])
@@ -222,10 +225,10 @@ func TestFatOnionFailureSpecVector(t *testing.T) {
 		require.Equal(t, expectedEncryptErrorData, obfuscatedData)
 	}
 
-	deobfuscator := NewOnionFatErrorDecrypter(&Circuit{
+	deobfuscator := NewOnionAttributableErrorDecrypter(&Circuit{
 		SessionKey:  sessionKey,
 		PaymentPath: paymentPath,
-	}, fatErrorTestStructure)
+	}, attributableErrorTestStructure)
 
 	// Emulate that sender node receives the failure message and trying to
 	// unwrap it, by applying obfuscation and checking the hmac.
@@ -244,19 +247,19 @@ func TestFatOnionFailureSpecVector(t *testing.T) {
 	require.Equal(t, len(paymentPath), decryptedError.SenderIdx)
 }
 
-// TestFatOnionFailureZeroesMessage checks that a garbage failure is attributed
-// to the first hop.
-func TestFatOnionFailureZeroesMessage(t *testing.T) {
+// TestAttributableOnionFailureZeroesMessage checks that a garbage failure is
+// attributed to the first hop.
+func TestAttributableOnionFailureZeroesMessage(t *testing.T) {
 	t.Parallel()
 
 	// Create numHops random sphinx paymentPath.
 	sessionKey, paymentPath := generateRandomPath(t)
 
 	// Emulate creation of the deobfuscator on the receiving onion error side.
-	deobfuscator := NewOnionFatErrorDecrypter(&Circuit{
+	deobfuscator := NewOnionAttributableErrorDecrypter(&Circuit{
 		SessionKey:  sessionKey,
 		PaymentPath: paymentPath,
-	}, fatErrorTestStructure)
+	}, attributableErrorTestStructure)
 
 	// Emulate that sender node receive the failure message and trying to
 	// unwrap it, by applying obfuscation and checking the hmac.
@@ -268,19 +271,19 @@ func TestFatOnionFailureZeroesMessage(t *testing.T) {
 	require.Equal(t, 1, decryptedError.SenderIdx)
 }
 
-// TestFatOnionFailureShortMessage checks that too short failure is attributed
-// to the first hop.
-func TestFatOnionFailureShortMessage(t *testing.T) {
+// TestAttributableOnionFailureShortMessage checks that too short failure is
+// attributed to the first hop.
+func TestAttributableOnionFailureShortMessage(t *testing.T) {
 	t.Parallel()
 
 	// Create numHops random sphinx paymentPath.
 	sessionKey, paymentPath := generateRandomPath(t)
 
 	// Emulate creation of the deobfuscator on the receiving onion error side.
-	deobfuscator := NewOnionFatErrorDecrypter(&Circuit{
+	deobfuscator := NewOnionAttributableErrorDecrypter(&Circuit{
 		SessionKey:  sessionKey,
 		PaymentPath: paymentPath,
-	}, fatErrorTestStructure)
+	}, attributableErrorTestStructure)
 
 	// Emulate that sender node receive the failure message and trying to
 	// unwrap it, by applying obfuscation and checking the hmac.