Add unit tests for configuration, cryptography, interfaces, and packet handling.

2025-05-07 18:24:52 -05:00
parent 3f141bf93b
commit 8114c3bda4
13 changed files with 1473 additions and 6 deletions
--- a/pkg/common/config_test.go
+++ b/pkg/common/config_test.go
@@ -0,0 +1,94 @@
+package common
+
+import (
+	"testing"
+)
+
+func TestNewReticulumConfig(t *testing.T) {
+	cfg := NewReticulumConfig()
+
+	if !cfg.EnableTransport {
+		t.Errorf("NewReticulumConfig() EnableTransport = %v; want true", cfg.EnableTransport)
+	}
+	if cfg.ShareInstance {
+		t.Errorf("NewReticulumConfig() ShareInstance = %v; want false", cfg.ShareInstance)
+	}
+	if cfg.SharedInstancePort != DEFAULT_SHARED_INSTANCE_PORT {
+		t.Errorf("NewReticulumConfig() SharedInstancePort = %d; want %d", cfg.SharedInstancePort, DEFAULT_SHARED_INSTANCE_PORT)
+	}
+	if cfg.InstanceControlPort != DEFAULT_INSTANCE_CONTROL_PORT {
+		t.Errorf("NewReticulumConfig() InstanceControlPort = %d; want %d", cfg.InstanceControlPort, DEFAULT_INSTANCE_CONTROL_PORT)
+	}
+	if cfg.PanicOnInterfaceErr {
+		t.Errorf("NewReticulumConfig() PanicOnInterfaceErr = %v; want false", cfg.PanicOnInterfaceErr)
+	}
+	if cfg.LogLevel != DEFAULT_LOG_LEVEL {
+		t.Errorf("NewReticulumConfig() LogLevel = %d; want %d", cfg.LogLevel, DEFAULT_LOG_LEVEL)
+	}
+	if len(cfg.Interfaces) != 0 {
+		t.Errorf("NewReticulumConfig() Interfaces length = %d; want 0", len(cfg.Interfaces))
+	}
+}
+
+func TestDefaultConfig(t *testing.T) {
+	cfg := DefaultConfig()
+
+	if !cfg.EnableTransport {
+		t.Errorf("DefaultConfig() EnableTransport = %v; want true", cfg.EnableTransport)
+	}
+	if cfg.ShareInstance {
+		t.Errorf("DefaultConfig() ShareInstance = %v; want false", cfg.ShareInstance)
+	}
+	if cfg.SharedInstancePort != DEFAULT_SHARED_INSTANCE_PORT {
+		t.Errorf("DefaultConfig() SharedInstancePort = %d; want %d", cfg.SharedInstancePort, DEFAULT_SHARED_INSTANCE_PORT)
+	}
+	if cfg.InstanceControlPort != DEFAULT_INSTANCE_CONTROL_PORT {
+		t.Errorf("DefaultConfig() InstanceControlPort = %d; want %d", cfg.InstanceControlPort, DEFAULT_INSTANCE_CONTROL_PORT)
+	}
+	if cfg.PanicOnInterfaceErr {
+		t.Errorf("DefaultConfig() PanicOnInterfaceErr = %v; want false", cfg.PanicOnInterfaceErr)
+	}
+	if cfg.LogLevel != DEFAULT_LOG_LEVEL {
+		t.Errorf("DefaultConfig() LogLevel = %d; want %d", cfg.LogLevel, DEFAULT_LOG_LEVEL)
+	}
+	if len(cfg.Interfaces) != 0 {
+		t.Errorf("DefaultConfig() Interfaces length = %d; want 0", len(cfg.Interfaces))
+	}
+	if cfg.AppName != "Go Client" {
+		t.Errorf("DefaultConfig() AppName = %q; want %q", cfg.AppName, "Go Client")
+	}
+	if cfg.AppAspect != "node" {
+		t.Errorf("DefaultConfig() AppAspect = %q; want %q", cfg.AppAspect, "node")
+	}
+}
+
+func TestReticulumConfig_Validate(t *testing.T) {
+	validConfig := DefaultConfig()
+	if err := validConfig.Validate(); err != nil {
+		t.Errorf("Validate() on default config failed: %v", err)
+	}
+
+	invalidPortConfig1 := DefaultConfig()
+	invalidPortConfig1.SharedInstancePort = 0
+	if err := invalidPortConfig1.Validate(); err == nil {
+		t.Errorf("Validate() did not return error for invalid SharedInstancePort 0")
+	}
+
+	invalidPortConfig2 := DefaultConfig()
+	invalidPortConfig2.SharedInstancePort = 65536
+	if err := invalidPortConfig2.Validate(); err == nil {
+		t.Errorf("Validate() did not return error for invalid SharedInstancePort 65536")
+	}
+
+	invalidPortConfig3 := DefaultConfig()
+	invalidPortConfig3.InstanceControlPort = 0
+	if err := invalidPortConfig3.Validate(); err == nil {
+		t.Errorf("Validate() did not return error for invalid InstanceControlPort 0")
+	}
+
+	invalidPortConfig4 := DefaultConfig()
+	invalidPortConfig4.InstanceControlPort = 65536
+	if err := invalidPortConfig4.Validate(); err == nil {
+		t.Errorf("Validate() did not return error for invalid InstanceControlPort 65536")
+	}
+}
--- a/pkg/cryptography/aes.go
+++ b/pkg/cryptography/aes.go
@@ -59,5 +59,9 @@ func DecryptAESCBC(key, ciphertext []byte) ([]byte, error) {

 	// Remove PKCS7 padding
 	padding := int(plaintext[len(plaintext)-1])
+	if padding == 0 || padding > len(plaintext) {
+		return nil, errors.New("invalid PKCS7 padding")
+	}
+	// TODO: Add check to ensure all padding bytes are correct?
 	return plaintext[:len(plaintext)-padding], nil
 }
--- a/pkg/cryptography/aes_test.go
+++ b/pkg/cryptography/aes_test.go
@@ -0,0 +1,86 @@
+package cryptography
+
+import (
+	"bytes"
+	"crypto/aes"
+	"crypto/rand"
+	"testing"
+)
+
+func TestAESCBCEncryptionDecryption(t *testing.T) {
+	// Generate a random key (AES-256)
+	key := make([]byte, 32)
+	if _, err := rand.Read(key); err != nil {
+		t.Fatalf("Failed to generate random key: %v", err)
+	}
+
+	testCases := []struct {
+		name      string
+		plaintext []byte
+	}{
+		{"ShortMessage", []byte("Hello")},
+		{"BlockSizeMessage", []byte("This is 16 bytes")},
+		{"LongMessage", []byte("This is a longer message that spans multiple AES blocks.")},
+		{"EmptyMessage", []byte("")},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			ciphertext, err := EncryptAESCBC(key, tc.plaintext)
+			if err != nil {
+				t.Fatalf("EncryptAESCBC failed: %v", err)
+			}
+
+			decrypted, err := DecryptAESCBC(key, ciphertext)
+			if err != nil {
+				t.Fatalf("DecryptAESCBC failed: %v", err)
+			}
+
+			if !bytes.Equal(tc.plaintext, decrypted) {
+				t.Errorf("Decrypted text does not match original plaintext. Got %q, want %q", decrypted, tc.plaintext)
+			}
+		})
+	}
+}
+
+func TestDecryptAESCBCErrorCases(t *testing.T) {
+	key := make([]byte, 32)
+	_, _ = rand.Read(key)
+
+	t.Run("CiphertextTooShort", func(t *testing.T) {
+		shortCiphertext := []byte{0x01, 0x02, 0x03} // Less than AES block size
+		_, err := DecryptAESCBC(key, shortCiphertext)
+		if err == nil {
+			t.Error("DecryptAESCBC should have failed for ciphertext shorter than block size, but it didn't")
+		}
+	})
+
+	t.Run("InvalidPadding", func(t *testing.T) {
+		// Encrypt something valid first
+		plaintext := []byte("valid data")
+		ciphertext, _ := EncryptAESCBC(key, plaintext)
+
+		// Tamper with the ciphertext (specifically the part that would affect padding)
+		if len(ciphertext) > aes.BlockSize {
+			ciphertext[len(ciphertext)-1] = ^ciphertext[len(ciphertext)-1] // Flip bits of last byte
+		}
+
+		_, err := DecryptAESCBC(key, ciphertext)
+		if err == nil {
+			// Note: Depending on the padding implementation and the nature of the tampering,
+			// CBC decryption might not always error out on bad padding. It might return garbage data.
+			// A more robust test might check the decrypted content, but error checking is a start.
+			t.Logf("DecryptAESCBC did not error on potentially invalid padding (this might be expected)")
+		}
+	})
+
+	t.Run("CiphertextNotMultipleOfBlockSize", func(t *testing.T) {
+		iv := make([]byte, aes.BlockSize)
+		_, _ = rand.Read(iv)
+		invalidCiphertext := append(iv, []byte{0x01, 0x02, 0x03}...) // IV + data not multiple of block size
+		_, err := DecryptAESCBC(key, invalidCiphertext)
+		if err == nil {
+			t.Error("DecryptAESCBC should have failed for ciphertext not multiple of block size, but it didn't")
+		}
+	})
+}
--- a/pkg/cryptography/curve25519_test.go
+++ b/pkg/cryptography/curve25519_test.go
@@ -0,0 +1,63 @@
+package cryptography
+
+import (
+	"bytes"
+	"testing"
+
+	"golang.org/x/crypto/curve25519"
+)
+
+func TestGenerateKeyPair(t *testing.T) {
+	priv1, pub1, err := GenerateKeyPair()
+	if err != nil {
+		t.Fatalf("GenerateKeyPair failed: %v", err)
+	}
+
+	if len(priv1) != curve25519.ScalarSize {
+		t.Errorf("Private key length is %d, want %d", len(priv1), curve25519.ScalarSize)
+	}
+	if len(pub1) != curve25519.PointSize {
+		t.Errorf("Public key length is %d, want %d", len(pub1), curve25519.PointSize)
+	}
+
+	// Generate another pair, should be different
+	priv2, pub2, err := GenerateKeyPair()
+	if err != nil {
+		t.Fatalf("Second GenerateKeyPair failed: %v", err)
+	}
+	if bytes.Equal(priv1, priv2) {
+		t.Error("Generated private keys are identical")
+	}
+	if bytes.Equal(pub1, pub2) {
+		t.Error("Generated public keys are identical")
+	}
+}
+
+func TestDeriveSharedSecret(t *testing.T) {
+	privA, pubA, err := GenerateKeyPair()
+	if err != nil {
+		t.Fatalf("GenerateKeyPair A failed: %v", err)
+	}
+	privB, pubB, err := GenerateKeyPair()
+	if err != nil {
+		t.Fatalf("GenerateKeyPair B failed: %v", err)
+	}
+
+	secretA, err := DeriveSharedSecret(privA, pubB)
+	if err != nil {
+		t.Fatalf("DeriveSharedSecret (A perspective) failed: %v", err)
+	}
+
+	secretB, err := DeriveSharedSecret(privB, pubA)
+	if err != nil {
+		t.Fatalf("DeriveSharedSecret (B perspective) failed: %v", err)
+	}
+
+	if !bytes.Equal(secretA, secretB) {
+		t.Errorf("Derived shared secrets do not match:\nSecret A: %x\nSecret B: %x", secretA, secretB)
+	}
+
+	if len(secretA) != curve25519.PointSize { // Shared secret length
+		t.Errorf("Shared secret length is %d, want %d", len(secretA), curve25519.PointSize)
+	}
+}
--- a/pkg/cryptography/ed25519_test.go
+++ b/pkg/cryptography/ed25519_test.go
@@ -0,0 +1,79 @@
+package cryptography
+
+import (
+	"crypto/ed25519"
+	"testing"
+)
+
+func TestGenerateSigningKeyPair(t *testing.T) {
+	pub1, priv1, err := GenerateSigningKeyPair()
+	if err != nil {
+		t.Fatalf("GenerateSigningKeyPair failed: %v", err)
+	}
+
+	if len(pub1) != ed25519.PublicKeySize {
+		t.Errorf("Public key length is %d, want %d", len(pub1), ed25519.PublicKeySize)
+	}
+	if len(priv1) != ed25519.PrivateKeySize {
+		t.Errorf("Private key length is %d, want %d", len(priv1), ed25519.PrivateKeySize)
+	}
+
+	// Generate another pair, should be different
+	pub2, priv2, err := GenerateSigningKeyPair()
+	if err != nil {
+		t.Fatalf("Second GenerateSigningKeyPair failed: %v", err)
+	}
+	if pub1.Equal(pub2) {
+		t.Error("Generated public keys are identical")
+	}
+	if priv1.Equal(priv2) {
+		t.Error("Generated private keys are identical")
+	}
+}
+
+func TestSignAndVerify(t *testing.T) {
+	pub, priv, err := GenerateSigningKeyPair()
+	if err != nil {
+		t.Fatalf("GenerateSigningKeyPair failed: %v", err)
+	}
+
+	message := []byte("This message needs to be signed.")
+
+	signature := Sign(priv, message)
+	if len(signature) != ed25519.SignatureSize {
+		t.Errorf("Signature length is %d, want %d", len(signature), ed25519.SignatureSize)
+	}
+
+	// Verify correct signature
+	if !Verify(pub, message, signature) {
+		t.Errorf("Verify failed for a valid signature")
+	}
+
+	// Verify with tampered message
+	tamperedMessage := append(message, '!')
+	if Verify(pub, tamperedMessage, signature) {
+		t.Errorf("Verify succeeded for a tampered message")
+	}
+
+	// Verify with tampered signature
+	tamperedSignature := append(signature[:len(signature)-1], ^signature[len(signature)-1])
+	if Verify(pub, message, tamperedSignature) {
+		t.Errorf("Verify succeeded for a tampered signature")
+	}
+
+	// Verify with wrong public key
+	wrongPub, _, _ := GenerateSigningKeyPair()
+	if Verify(wrongPub, message, signature) {
+		t.Errorf("Verify succeeded with the wrong public key")
+	}
+
+	// Verify empty message
+	emptyMessage := []byte("")
+	emptySig := Sign(priv, emptyMessage)
+	if !Verify(pub, emptyMessage, emptySig) {
+		t.Errorf("Verify failed for an empty message")
+	}
+	if Verify(pub, message, emptySig) {
+		t.Errorf("Verify succeeded comparing non-empty message with empty signature")
+	}
+}
--- a/pkg/cryptography/hkdf_test.go
+++ b/pkg/cryptography/hkdf_test.go
@@ -0,0 +1,108 @@
+package cryptography
+
+import (
+	"bytes"
+	"testing"
+)
+
+func TestDeriveKey(t *testing.T) {
+	secret := []byte("test-secret")
+	salt := []byte("test-salt")
+	info := []byte("test-info")
+	length := 32 // Desired key length
+
+	key1, err := DeriveKey(secret, salt, info, length)
+	if err != nil {
+		t.Fatalf("DeriveKey failed: %v", err)
+	}
+
+	if len(key1) != length {
+		t.Errorf("DeriveKey returned key of length %d; want %d", len(key1), length)
+	}
+
+	// Derive another key with the same parameters, should be identical
+	key2, err := DeriveKey(secret, salt, info, length)
+	if err != nil {
+		t.Fatalf("Second DeriveKey failed: %v", err)
+	}
+	if !bytes.Equal(key1, key2) {
+		t.Errorf("DeriveKey is not deterministic. Got %x and %x for the same inputs", key1, key2)
+	}
+
+	// Derive a key with different info, should be different
+	differentInfo := []byte("different-info")
+	key3, err := DeriveKey(secret, salt, differentInfo, length)
+	if err != nil {
+		t.Fatalf("DeriveKey with different info failed: %v", err)
+	}
+	if bytes.Equal(key1, key3) {
+		t.Errorf("DeriveKey produced the same key for different info strings")
+	}
+
+	// Derive a key with different salt, should be different
+	differentSalt := []byte("different-salt")
+	key4, err := DeriveKey(secret, differentSalt, info, length)
+	if err != nil {
+		t.Fatalf("DeriveKey with different salt failed: %v", err)
+	}
+	if bytes.Equal(key1, key4) {
+		t.Errorf("DeriveKey produced the same key for different salts")
+	}
+
+	// Derive a key with different secret, should be different
+	differentSecret := []byte("different-secret")
+	key5, err := DeriveKey(differentSecret, salt, info, length)
+	if err != nil {
+		t.Fatalf("DeriveKey with different secret failed: %v", err)
+	}
+	if bytes.Equal(key1, key5) {
+		t.Errorf("DeriveKey produced the same key for different secrets")
+	}
+
+	// Derive a key with different length
+	differentLength := 64
+	key6, err := DeriveKey(secret, salt, info, differentLength)
+	if err != nil {
+		t.Fatalf("DeriveKey with different length failed: %v", err)
+	}
+	if len(key6) != differentLength {
+		t.Errorf("DeriveKey returned key of length %d; want %d", len(key6), differentLength)
+	}
+}
+
+func TestDeriveKeyEdgeCases(t *testing.T) {
+	secret := []byte("test-secret")
+	salt := []byte("test-salt")
+	info := []byte("test-info")
+
+	t.Run("EmptySecret", func(t *testing.T) {
+		_, err := DeriveKey([]byte{}, salt, info, 32)
+		if err != nil {
+			t.Errorf("DeriveKey failed with empty secret: %v", err)
+		}
+	})
+
+	t.Run("EmptySalt", func(t *testing.T) {
+		_, err := DeriveKey(secret, []byte{}, info, 32)
+		if err != nil {
+			t.Errorf("DeriveKey failed with empty salt: %v", err)
+		}
+	})
+
+	t.Run("EmptyInfo", func(t *testing.T) {
+		_, err := DeriveKey(secret, salt, []byte{}, 32)
+		if err != nil {
+			t.Errorf("DeriveKey failed with empty info: %v", err)
+		}
+	})
+
+	t.Run("ZeroLength", func(t *testing.T) {
+		key, err := DeriveKey(secret, salt, info, 0)
+		if err != nil {
+			t.Errorf("DeriveKey failed with zero length: %v", err)
+		}
+		if len(key) != 0 {
+			t.Errorf("DeriveKey with zero length returned non-empty key: %x", key)
+		}
+	})
+}
--- a/pkg/cryptography/hmac_test.go
+++ b/pkg/cryptography/hmac_test.go
@@ -0,0 +1,80 @@
+package cryptography
+
+import (
+	"testing"
+)
+
+func TestGenerateHMACKey(t *testing.T) {
+	testSizes := []int{16, 32, 64}
+	for _, size := range testSizes {
+		t.Run("Size"+string(rune(size)), func(t *testing.T) { // Simple name conversion
+			key, err := GenerateHMACKey(size)
+			if err != nil {
+				t.Fatalf("GenerateHMACKey(%d) failed: %v", size, err)
+			}
+			if len(key) != size {
+				t.Errorf("GenerateHMACKey(%d) returned key of length %d; want %d", size, len(key), size)
+			}
+
+			// Check if key is not all zeros (basic check for randomness)
+			isZero := true
+			for _, b := range key {
+				if b != 0 {
+					isZero = false
+					break
+				}
+			}
+			if isZero {
+				t.Errorf("GenerateHMACKey(%d) returned an all-zero key", size)
+			}
+		})
+	}
+}
+
+func TestComputeAndValidateHMAC(t *testing.T) {
+	key, err := GenerateHMACKey(32) // Use SHA256 key size
+	if err != nil {
+		t.Fatalf("Failed to generate HMAC key: %v", err)
+	}
+
+	message := []byte("This is a test message.")
+
+	// Compute HMAC
+	computedHMAC := ComputeHMAC(key, message)
+	if len(computedHMAC) != 32 { // SHA256 output size
+		t.Errorf("ComputeHMAC returned HMAC of length %d; want 32", len(computedHMAC))
+	}
+
+	// Validate correct HMAC
+	if !ValidateHMAC(key, message, computedHMAC) {
+		t.Errorf("ValidateHMAC failed for correctly computed HMAC")
+	}
+
+	// Validate incorrect HMAC (tampered message)
+	tamperedMessage := append(message, byte('!'))
+	if ValidateHMAC(key, tamperedMessage, computedHMAC) {
+		t.Errorf("ValidateHMAC succeeded for tampered message")
+	}
+
+	// Validate incorrect HMAC (tampered key)
+	wrongKey, _ := GenerateHMACKey(32)
+	if ValidateHMAC(wrongKey, message, computedHMAC) {
+		t.Errorf("ValidateHMAC succeeded for incorrect key")
+	}
+
+	// Validate incorrect HMAC (tampered HMAC)
+	tamperedHMAC := append(computedHMAC[:len(computedHMAC)-1], ^computedHMAC[len(computedHMAC)-1])
+	if ValidateHMAC(key, message, tamperedHMAC) {
+		t.Errorf("ValidateHMAC succeeded for tampered HMAC")
+	}
+
+	// Validate empty message
+	emptyMessage := []byte("")
+	emptyHMAC := ComputeHMAC(key, emptyMessage)
+	if !ValidateHMAC(key, emptyMessage, emptyHMAC) {
+		t.Errorf("ValidateHMAC failed for empty message")
+	}
+	if ValidateHMAC(key, message, emptyHMAC) {
+		t.Errorf("ValidateHMAC succeeded comparing non-empty message with empty HMAC")
+	}
+}
--- a/pkg/interfaces/auto_test.go
+++ b/pkg/interfaces/auto_test.go
@@ -0,0 +1,290 @@
+package interfaces
+
+import (
+	"net"
+	"testing"
+	"time"
+
+	"github.com/Sudo-Ivan/reticulum-go/pkg/common"
+)
+
+func TestNewAutoInterface(t *testing.T) {
+	t.Run("DefaultConfig", func(t *testing.T) {
+		config := &common.InterfaceConfig{Enabled: true}
+		ai, err := NewAutoInterface("autoDefault", config)
+		if err != nil {
+			t.Fatalf("NewAutoInterface failed with default config: %v", err)
+		}
+		if ai == nil {
+			t.Fatal("NewAutoInterface returned nil with default config")
+		}
+
+		if ai.GetName() != "autoDefault" {
+			t.Errorf("GetName() = %s; want autoDefault", ai.GetName())
+		}
+		if ai.GetType() != common.IF_TYPE_AUTO {
+			t.Errorf("GetType() = %v; want %v", ai.GetType(), common.IF_TYPE_AUTO)
+		}
+		if ai.discoveryPort != DEFAULT_DISCOVERY_PORT {
+			t.Errorf("discoveryPort = %d; want %d", ai.discoveryPort, DEFAULT_DISCOVERY_PORT)
+		}
+		if ai.dataPort != DEFAULT_DATA_PORT {
+			t.Errorf("dataPort = %d; want %d", ai.dataPort, DEFAULT_DATA_PORT)
+		}
+		if string(ai.groupID) != "reticulum" {
+			t.Errorf("groupID = %s; want reticulum", string(ai.groupID))
+		}
+		if ai.discoveryScope != SCOPE_LINK {
+			t.Errorf("discoveryScope = %s; want %s", ai.discoveryScope, SCOPE_LINK)
+		}
+		if len(ai.peers) != 0 {
+			t.Errorf("peers map not empty initially")
+		}
+	})
+
+	t.Run("CustomConfig", func(t *testing.T) {
+		config := &common.InterfaceConfig{
+			Enabled: true,
+			Port:    12345, // Custom discovery port
+			GroupID: "customGroup",
+		}
+		ai, err := NewAutoInterface("autoCustom", config)
+		if err != nil {
+			t.Fatalf("NewAutoInterface failed with custom config: %v", err)
+		}
+		if ai == nil {
+			t.Fatal("NewAutoInterface returned nil with custom config")
+		}
+
+		if ai.discoveryPort != 12345 {
+			t.Errorf("discoveryPort = %d; want 12345", ai.discoveryPort)
+		}
+		if string(ai.groupID) != "customGroup" {
+			t.Errorf("groupID = %s; want customGroup", string(ai.groupID))
+		}
+	})
+}
+
+// mockAutoInterface embeds AutoInterface but overrides methods that start goroutines
+type mockAutoInterface struct {
+	*AutoInterface
+}
+
+func newMockAutoInterface(name string, config *common.InterfaceConfig) (*mockAutoInterface, error) {
+	ai, err := NewAutoInterface(name, config)
+	if err != nil {
+		return nil, err
+	}
+
+	// Initialize maps that would normally be initialized in Start()
+	ai.peers = make(map[string]*Peer)
+	ai.linkLocalAddrs = make([]string, 0)
+	ai.adoptedInterfaces = make(map[string]string)
+	ai.interfaceServers = make(map[string]*net.UDPConn)
+	ai.multicastEchoes = make(map[string]time.Time)
+
+	return &mockAutoInterface{AutoInterface: ai}, nil
+}
+
+func (m *mockAutoInterface) Start() error {
+	// Don't start any goroutines
+	return nil
+}
+
+func (m *mockAutoInterface) Stop() error {
+	// Don't try to close connections that were never opened
+	return nil
+}
+
+// mockHandlePeerAnnounce is a test-only method that doesn't handle its own locking
+func (m *mockAutoInterface) mockHandlePeerAnnounce(addr *net.UDPAddr, data []byte, ifaceName string) {
+	peerAddr := addr.IP.String() + "%" + addr.Zone
+
+	for _, localAddr := range m.linkLocalAddrs {
+		if peerAddr == localAddr {
+			m.multicastEchoes[ifaceName] = time.Now()
+			return
+		}
+	}
+
+	if _, exists := m.peers[peerAddr]; !exists {
+		m.peers[peerAddr] = &Peer{
+			ifaceName: ifaceName,
+			lastHeard: time.Now(),
+		}
+	} else {
+		m.peers[peerAddr].lastHeard = time.Now()
+	}
+}
+
+func TestAutoInterfacePeerManagement(t *testing.T) {
+	// Use a shorter timeout for testing
+	testTimeout := 100 * time.Millisecond
+
+	config := &common.InterfaceConfig{Enabled: true}
+	ai, err := newMockAutoInterface("autoPeerTest", config)
+	if err != nil {
+		t.Fatalf("Failed to create mock interface: %v", err)
+	}
+
+	// Create a done channel to signal goroutine cleanup
+	done := make(chan struct{})
+
+	// Start peer management with done channel
+	go func() {
+		ticker := time.NewTicker(testTimeout)
+		defer ticker.Stop()
+
+		for {
+			select {
+			case <-ticker.C:
+				ai.mutex.Lock()
+				now := time.Now()
+				for addr, peer := range ai.peers {
+					if now.Sub(peer.lastHeard) > testTimeout {
+						delete(ai.peers, addr)
+					}
+				}
+				ai.mutex.Unlock()
+			case <-done:
+				return
+			}
+		}
+	}()
+
+	// Ensure cleanup
+	defer func() {
+		close(done)
+		ai.Stop()
+	}()
+
+	// Simulate receiving peer announces
+	peer1AddrStr := "fe80::1%eth0"
+	peer2AddrStr := "fe80::2%eth0"
+	localAddrStr := "fe80::aaaa%eth0" // Simulate a local address
+
+	peer1Addr := &net.UDPAddr{IP: net.ParseIP("fe80::1"), Zone: "eth0"}
+	peer2Addr := &net.UDPAddr{IP: net.ParseIP("fe80::2"), Zone: "eth0"}
+	localAddr := &net.UDPAddr{IP: net.ParseIP("fe80::aaaa"), Zone: "eth0"}
+
+	// Add a simulated local address to avoid adding it as a peer
+	ai.mutex.Lock()
+	ai.linkLocalAddrs = append(ai.linkLocalAddrs, localAddrStr)
+	ai.mutex.Unlock()
+
+	t.Run("AddPeer1", func(t *testing.T) {
+		ai.mutex.Lock()
+		ai.mockHandlePeerAnnounce(peer1Addr, []byte("announce1"), "eth0")
+		ai.mutex.Unlock()
+
+		// Give a small amount of time for the peer to be processed
+		time.Sleep(10 * time.Millisecond)
+
+		ai.mutex.RLock()
+		count := len(ai.peers)
+		peer, exists := ai.peers[peer1AddrStr]
+		var ifaceName string
+		if exists {
+			ifaceName = peer.ifaceName
+		}
+		ai.mutex.RUnlock()
+
+		if count != 1 {
+			t.Fatalf("Expected 1 peer, got %d", count)
+		}
+		if !exists {
+			t.Fatalf("Peer %s not found in map", peer1AddrStr)
+		}
+		if ifaceName != "eth0" {
+			t.Errorf("Peer %s interface name = %s; want eth0", peer1AddrStr, ifaceName)
+		}
+	})
+
+	t.Run("AddPeer2", func(t *testing.T) {
+		ai.mutex.Lock()
+		ai.mockHandlePeerAnnounce(peer2Addr, []byte("announce2"), "eth0")
+		ai.mutex.Unlock()
+
+		// Give a small amount of time for the peer to be processed
+		time.Sleep(10 * time.Millisecond)
+
+		ai.mutex.RLock()
+		count := len(ai.peers)
+		_, exists := ai.peers[peer2AddrStr]
+		ai.mutex.RUnlock()
+
+		if count != 2 {
+			t.Fatalf("Expected 2 peers, got %d", count)
+		}
+		if !exists {
+			t.Fatalf("Peer %s not found in map", peer2AddrStr)
+		}
+	})
+
+	t.Run("IgnoreLocalAnnounce", func(t *testing.T) {
+		ai.mutex.Lock()
+		ai.mockHandlePeerAnnounce(localAddr, []byte("local_announce"), "eth0")
+		ai.mutex.Unlock()
+
+		// Give a small amount of time for the peer to be processed
+		time.Sleep(10 * time.Millisecond)
+
+		ai.mutex.RLock()
+		count := len(ai.peers)
+		ai.mutex.RUnlock()
+
+		if count != 2 {
+			t.Fatalf("Expected 2 peers after local announce, got %d", count)
+		}
+	})
+
+	t.Run("UpdatePeerTimestamp", func(t *testing.T) {
+		ai.mutex.RLock()
+		peer, exists := ai.peers[peer1AddrStr]
+		var initialTime time.Time
+		if exists {
+			initialTime = peer.lastHeard
+		}
+		ai.mutex.RUnlock()
+
+		if !exists {
+			t.Fatalf("Peer %s not found before timestamp update", peer1AddrStr)
+		}
+
+		ai.mutex.Lock()
+		ai.mockHandlePeerAnnounce(peer1Addr, []byte("announce1_again"), "eth0")
+		ai.mutex.Unlock()
+
+		// Give a small amount of time for the peer to be processed
+		time.Sleep(10 * time.Millisecond)
+
+		ai.mutex.RLock()
+		peer, exists = ai.peers[peer1AddrStr]
+		var updatedTime time.Time
+		if exists {
+			updatedTime = peer.lastHeard
+		}
+		ai.mutex.RUnlock()
+
+		if !exists {
+			t.Fatalf("Peer %s not found after timestamp update", peer1AddrStr)
+		}
+
+		if !updatedTime.After(initialTime) {
+			t.Errorf("Peer timestamp was not updated after receiving another announce")
+		}
+	})
+
+	t.Run("PeerTimeout", func(t *testing.T) {
+		// Wait for peer timeout
+		time.Sleep(testTimeout * 2)
+
+		ai.mutex.RLock()
+		count := len(ai.peers)
+		ai.mutex.RUnlock()
+
+		if count != 0 {
+			t.Errorf("Expected all peers to timeout, got %d peers", count)
+		}
+	})
+}
--- a/pkg/interfaces/interface_test.go
+++ b/pkg/interfaces/interface_test.go
@@ -0,0 +1,230 @@
+package interfaces
+
+import (
+	"bytes"
+	"net"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/Sudo-Ivan/reticulum-go/pkg/common"
+)
+
+func TestBaseInterfaceStateChanges(t *testing.T) {
+	bi := NewBaseInterface("test", common.IF_TYPE_TCP, false) // Start disabled
+
+	if bi.IsEnabled() {
+		t.Error("Newly created disabled interface reports IsEnabled() == true")
+	}
+	if bi.IsOnline() {
+		t.Error("Newly created disabled interface reports IsOnline() == true")
+	}
+	if bi.IsDetached() {
+		t.Error("Newly created interface reports IsDetached() == true")
+	}
+
+	bi.Enable()
+	if !bi.IsEnabled() {
+		t.Error("After Enable(), IsEnabled() == false")
+	}
+	if !bi.IsOnline() {
+		t.Error("After Enable(), IsOnline() == false")
+	}
+	if bi.IsDetached() {
+		t.Error("After Enable(), IsDetached() == true")
+	}
+
+	bi.Detach()
+	if bi.IsEnabled() {
+		t.Error("After Detach(), IsEnabled() == true")
+	}
+	if bi.IsOnline() {
+		t.Error("After Detach(), IsOnline() == true")
+	}
+	if !bi.IsDetached() {
+		t.Error("After Detach(), IsDetached() == false")
+	}
+
+	// Reset for Disable test
+	bi = NewBaseInterface("test2", common.IF_TYPE_UDP, true) // Start enabled
+	if !bi.Enabled {                                         // Check the Enabled field directly first
+		t.Error("Newly created enabled interface reports Enabled == false")
+	}
+	if bi.IsEnabled() { // IsEnabled should still be false because Online is false
+		t.Error("Newly created enabled interface reports IsEnabled() == true before Enable() is called")
+	}
+
+	bi.Enable()          // Explicitly enable to set Online = true
+	if !bi.IsEnabled() { // Now IsEnabled should be true
+		t.Error("After Enable() on initially enabled interface, IsEnabled() == false")
+	}
+
+	bi.Disable()
+	if bi.Enabled { // Check Enabled field after Disable()
+		t.Error("After Disable(), Enabled == true")
+	}
+	if bi.IsOnline() {
+		t.Error("After Disable(), IsOnline() == true")
+	}
+	if bi.IsDetached() { // Disable doesn't detach
+		t.Error("After Disable(), IsDetached() == true")
+	}
+}
+
+func TestBaseInterfaceGetters(t *testing.T) {
+	bi := NewBaseInterface("getterTest", common.IF_TYPE_AUTO, true)
+
+	if bi.GetName() != "getterTest" {
+		t.Errorf("GetName() = %s; want getterTest", bi.GetName())
+	}
+	if bi.GetType() != common.IF_TYPE_AUTO {
+		t.Errorf("GetType() = %v; want %v", bi.GetType(), common.IF_TYPE_AUTO)
+	}
+	if bi.GetMode() != common.IF_MODE_FULL {
+		t.Errorf("GetMode() = %v; want %v", bi.GetMode(), common.IF_MODE_FULL)
+	}
+	if bi.GetMTU() != common.DEFAULT_MTU { // Assuming default MTU
+		t.Errorf("GetMTU() = %d; want %d", bi.GetMTU(), common.DEFAULT_MTU)
+	}
+}
+
+func TestBaseInterfaceCallbacks(t *testing.T) {
+	bi := NewBaseInterface("callbackTest", common.IF_TYPE_TCP, true)
+	var wg sync.WaitGroup
+	var callbackCalled bool
+
+	callback := func(data []byte, iface common.NetworkInterface) {
+		if len(data) != 5 {
+			t.Errorf("Callback received data length %d; want 5", len(data))
+		}
+		if iface.GetName() != "callbackTest" {
+			t.Errorf("Callback received interface name %s; want callbackTest", iface.GetName())
+		}
+		callbackCalled = true
+		wg.Done()
+	}
+
+	bi.SetPacketCallback(callback)
+	if bi.GetPacketCallback() == nil { // Cannot directly compare functions
+		t.Error("GetPacketCallback() returned nil after SetPacketCallback()")
+	}
+
+	wg.Add(1)
+	go bi.ProcessIncoming([]byte{1, 2, 3, 4, 5}) // Run in goroutine as callback might block
+
+	// Wait for callback or timeout
+	waitTimeout(&wg, 1*time.Second, t)
+
+	if !callbackCalled {
+		t.Error("Packet callback was not called after ProcessIncoming")
+	}
+}
+
+func TestBaseInterfaceStats(t *testing.T) {
+	bi := NewBaseInterface("statsTest", common.IF_TYPE_UDP, true)
+	bi.Enable() // Need to be Online for ProcessOutgoing
+
+	data1 := []byte{1, 2, 3}
+	data2 := []byte{4, 5, 6, 7, 8}
+
+	bi.ProcessIncoming(data1)
+	if bi.RxBytes != uint64(len(data1)) {
+		t.Errorf("RxBytes = %d; want %d after first ProcessIncoming", bi.RxBytes, len(data1))
+	}
+
+	bi.ProcessIncoming(data2)
+	if bi.RxBytes != uint64(len(data1)+len(data2)) {
+		t.Errorf("RxBytes = %d; want %d after second ProcessIncoming", bi.RxBytes, len(data1)+len(data2))
+	}
+
+	// ProcessOutgoing only updates TxBytes in BaseInterface
+	err := bi.ProcessOutgoing(data1)
+	if err != nil {
+		t.Fatalf("ProcessOutgoing failed: %v", err)
+	}
+	if bi.TxBytes != uint64(len(data1)) {
+		t.Errorf("TxBytes = %d; want %d after first ProcessOutgoing", bi.TxBytes, len(data1))
+	}
+
+	err = bi.ProcessOutgoing(data2)
+	if err != nil {
+		t.Fatalf("ProcessOutgoing failed: %v", err)
+	}
+	if bi.TxBytes != uint64(len(data1)+len(data2)) {
+		t.Errorf("TxBytes = %d; want %d after second ProcessOutgoing", bi.TxBytes, len(data1)+len(data2))
+	}
+}
+
+// Helper function to wait for a WaitGroup with a timeout
+func waitTimeout(wg *sync.WaitGroup, timeout time.Duration, t *testing.T) {
+	c := make(chan struct{})
+	go func() {
+		defer close(c)
+		wg.Wait()
+	}()
+	select {
+	case <-c:
+		// Completed normally
+	case <-time.After(timeout):
+		t.Fatal("Timed out waiting for WaitGroup")
+	}
+}
+
+// Minimal mock interface for InterceptedInterface test
+type mockInterface struct {
+	BaseInterface
+	sendCalled bool
+	sendData   []byte
+}
+
+func (m *mockInterface) Send(data []byte, addr string) error {
+	m.sendCalled = true
+	m.sendData = data
+	return nil
+}
+
+// Add other methods to satisfy the Interface interface (can be minimal/panic)
+func (m *mockInterface) GetType() common.InterfaceType                  { return common.IF_TYPE_NONE }
+func (m *mockInterface) GetMode() common.InterfaceMode                  { return common.IF_MODE_FULL }
+func (m *mockInterface) ProcessIncoming(data []byte)                    {}
+func (m *mockInterface) ProcessOutgoing(data []byte) error              { return nil }
+func (m *mockInterface) SendPathRequest([]byte) error                   { return nil }
+func (m *mockInterface) SendLinkPacket([]byte, []byte, time.Time) error { return nil }
+func (m *mockInterface) Start() error                                   { return nil }
+func (m *mockInterface) Stop() error                                    { return nil }
+func (m *mockInterface) GetConn() net.Conn                              { return nil }
+func (m *mockInterface) GetBandwidthAvailable() bool                    { return true }
+
+func TestInterceptedInterface(t *testing.T) {
+	mockBase := &mockInterface{}
+	var interceptorCalled bool
+	var interceptedData []byte
+
+	interceptor := func(data []byte, iface common.NetworkInterface) error {
+		interceptorCalled = true
+		interceptedData = data
+		return nil
+	}
+
+	intercepted := NewInterceptedInterface(mockBase, interceptor)
+
+	testData := []byte("intercept me")
+	err := intercepted.Send(testData, "dummy_addr")
+	if err != nil {
+		t.Fatalf("Intercepted Send failed: %v", err)
+	}
+
+	if !interceptorCalled {
+		t.Error("Interceptor function was not called")
+	}
+	if !bytes.Equal(interceptedData, testData) {
+		t.Errorf("Interceptor received data %x; want %x", interceptedData, testData)
+	}
+
+	if !mockBase.sendCalled {
+		t.Error("Original Send function was not called")
+	}
+	if !bytes.Equal(mockBase.sendData, testData) {
+		t.Errorf("Original Send received data %x; want %x", mockBase.sendData, testData)
+	}
+}
--- a/pkg/interfaces/tcp_test.go
+++ b/pkg/interfaces/tcp_test.go
@@ -0,0 +1,52 @@
+package interfaces
+
+import (
+	"bytes"
+	"testing"
+)
+
+func TestEscapeHDLC(t *testing.T) {
+	testCases := []struct {
+		name     string
+		input    []byte
+		expected []byte
+	}{
+		{"NoEscape", []byte{0x01, 0x02, 0x03}, []byte{0x01, 0x02, 0x03}},
+		{"EscapeFlag", []byte{0x01, HDLC_FLAG, 0x03}, []byte{0x01, HDLC_ESC, HDLC_FLAG ^ HDLC_ESC_MASK, 0x03}},
+		{"EscapeEsc", []byte{0x01, HDLC_ESC, 0x03}, []byte{0x01, HDLC_ESC, HDLC_ESC ^ HDLC_ESC_MASK, 0x03}},
+		{"EscapeBoth", []byte{HDLC_FLAG, HDLC_ESC}, []byte{HDLC_ESC, HDLC_FLAG ^ HDLC_ESC_MASK, HDLC_ESC, HDLC_ESC ^ HDLC_ESC_MASK}},
+		{"Empty", []byte{}, []byte{}},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			result := escapeHDLC(tc.input)
+			if !bytes.Equal(result, tc.expected) {
+				t.Errorf("escapeHDLC(%x) = %x; want %x", tc.input, result, tc.expected)
+			}
+		})
+	}
+}
+
+func TestEscapeKISS(t *testing.T) {
+	testCases := []struct {
+		name     string
+		input    []byte
+		expected []byte
+	}{
+		{"NoEscape", []byte{0x01, 0x02, 0x03}, []byte{0x01, 0x02, 0x03}},
+		{"EscapeFEND", []byte{0x01, KISS_FEND, 0x03}, []byte{0x01, KISS_FESC, KISS_TFEND, 0x03}},
+		{"EscapeFESC", []byte{0x01, KISS_FESC, 0x03}, []byte{0x01, KISS_FESC, KISS_TFESC, 0x03}},
+		{"EscapeBoth", []byte{KISS_FEND, KISS_FESC}, []byte{KISS_FESC, KISS_TFEND, KISS_FESC, KISS_TFESC}},
+		{"Empty", []byte{}, []byte{}},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			result := escapeKISS(tc.input)
+			if !bytes.Equal(result, tc.expected) {
+				t.Errorf("escapeKISS(%x) = %x; want %x", tc.input, result, tc.expected)
+			}
+		})
+	}
+}
--- a/pkg/interfaces/udp_test.go
+++ b/pkg/interfaces/udp_test.go
@@ -0,0 +1,93 @@
+package interfaces
+
+import (
+	"testing"
+
+	"github.com/Sudo-Ivan/reticulum-go/pkg/common"
+)
+
+func TestNewUDPInterface(t *testing.T) {
+	validAddr := "127.0.0.1:0" // Use port 0 for OS to assign a free port
+	validTarget := "127.0.0.1:8080"
+	invalidAddr := "invalid-address"
+
+	t.Run("ValidConfig", func(t *testing.T) {
+		ui, err := NewUDPInterface("udpValid", validAddr, validTarget, true)
+		if err != nil {
+			t.Fatalf("NewUDPInterface failed with valid config: %v", err)
+		}
+		if ui == nil {
+			t.Fatal("NewUDPInterface returned nil interface with valid config")
+		}
+		if ui.GetName() != "udpValid" {
+			t.Errorf("GetName() = %s; want udpValid", ui.GetName())
+		}
+		if ui.GetType() != common.IF_TYPE_UDP {
+			t.Errorf("GetType() = %v; want %v", ui.GetType(), common.IF_TYPE_UDP)
+		}
+		if ui.addr.String() != validAddr && ui.addr.Port == 0 { // Check if address resolved, port 0 is special
+			// Allow OS-assigned port if 0 was specified
+		} else if ui.addr.String() != validAddr {
+			// t.Errorf("Resolved addr = %s; want %s", ui.addr.String(), validAddr) //This check is flaky with port 0
+		}
+		if ui.targetAddr.String() != validTarget {
+			t.Errorf("Resolved targetAddr = %s; want %s", ui.targetAddr.String(), validTarget)
+		}
+		if !ui.Enabled { // BaseInterface field
+			t.Error("Interface not enabled by default when requested")
+		}
+		if ui.IsOnline() { // Should be offline initially
+			t.Error("Interface online initially")
+		}
+	})
+
+	t.Run("ValidConfigNoTarget", func(t *testing.T) {
+		ui, err := NewUDPInterface("udpNoTarget", validAddr, "", true)
+		if err != nil {
+			t.Fatalf("NewUDPInterface failed with valid config (no target): %v", err)
+		}
+		if ui == nil {
+			t.Fatal("NewUDPInterface returned nil interface with valid config (no target)")
+		}
+		if ui.targetAddr != nil {
+			t.Errorf("targetAddr = %v; want nil", ui.targetAddr)
+		}
+	})
+
+	t.Run("InvalidAddress", func(t *testing.T) {
+		_, err := NewUDPInterface("udpInvalidAddr", invalidAddr, validTarget, true)
+		if err == nil {
+			t.Error("NewUDPInterface succeeded with invalid address")
+		}
+	})
+
+	t.Run("InvalidTarget", func(t *testing.T) {
+		_, err := NewUDPInterface("udpInvalidTarget", validAddr, invalidAddr, true)
+		if err == nil {
+			t.Error("NewUDPInterface succeeded with invalid target address")
+		}
+	})
+}
+
+func TestUDPInterfaceState(t *testing.T) {
+	// Basic state tests are covered by BaseInterface tests
+	// Add specific UDP ones if needed, e.g., involving the conn
+	addr := "127.0.0.1:0"
+	ui, _ := NewUDPInterface("udpState", addr, "", true)
+
+	if ui.conn != nil {
+		t.Error("conn field is not nil before Start()")
+	}
+
+	// We don't call Start() here because it requires actual network binding
+	// Testing Send requires Start() and a listener, which is too complex for unit tests here
+
+	// Test Detach
+	ui.Detach()
+	if !ui.IsDetached() {
+		t.Error("IsDetached() is false after Detach()")
+	}
+
+	// Further tests on Send/ProcessOutgoing/readLoop would require mocking net.UDPConn
+	// or setting up a local listener.
+}
--- a/pkg/packet/packet.go
+++ b/pkg/packet/packet.go
@@ -115,9 +115,13 @@ func (p *Packet) Pack() error {

 	log.Printf("[DEBUG-6] Packing packet: type=%d, header=%d", p.PacketType, p.HeaderType)

-	// Create header byte
-	flags := byte(p.HeaderType<<6) | byte(p.ContextFlag<<5) |
-		byte(p.TransportType<<4) | byte(p.DestinationType<<2) | byte(p.PacketType)
+	// Create header byte (Corrected order)
+	flags := byte(0)
+	flags |= (p.HeaderType << 6) & 0b01000000
+	flags |= (p.ContextFlag << 5) & 0b00100000
+	flags |= (p.TransportType << 4) & 0b00010000
+	flags |= (p.DestinationType << 2) & 0b00001100
+	flags |= p.PacketType & 0b00000011

 	header := []byte{flags, p.Hops}
 	log.Printf("[DEBUG-5] Created packet header: flags=%08b, hops=%d", flags, p.Hops)
@@ -193,11 +197,19 @@ func (p *Packet) GetHash() []byte {
 }

 func (p *Packet) getHashablePart() []byte {
-	hashable := []byte{p.Raw[0] & 0b00001111}
+	hashable := []byte{p.Raw[0] & 0b00001111} // Lower 4 bits of flags
 	if p.HeaderType == HeaderType2 {
-		hashable = append(hashable, p.Raw[18:]...)
+		// Match Python: Start hash from DestHash (index 18), skipping TransportID
+		dstLen := 16 // RNS.Identity.TRUNCATED_HASHLENGTH / 8
+		startIndex := dstLen + 2
+		if len(p.Raw) > startIndex {
+			hashable = append(hashable, p.Raw[startIndex:]...)
+		}
 	} else {
-		hashable = append(hashable, p.Raw[2:]...)
+		// Match Python: Start hash from DestHash (index 2)
+		if len(p.Raw) > 2 {
+			hashable = append(hashable, p.Raw[2:]...)
+		}
 	}
 	return hashable
 }
--- a/pkg/packet/packet_test.go
+++ b/pkg/packet/packet_test.go
@@ -0,0 +1,276 @@
+package packet
+
+import (
+	"bytes"
+	"crypto/rand"
+	"testing"
+)
+
+func randomBytes(n int) []byte {
+	b := make([]byte, n)
+	_, err := rand.Read(b)
+	if err != nil {
+		panic("Failed to generate random bytes: " + err.Error())
+	}
+	return b
+}
+
+func TestPacketPackUnpack(t *testing.T) {
+	testCases := []struct {
+		name             string
+		headerType       byte
+		packetType       byte
+		transportType    byte
+		destType         byte
+		context          byte
+		contextFlag      byte
+		dataSize         int
+		needsTransportID bool
+	}{
+		{
+			name:             "HeaderType1_Data_NoContextFlag",
+			headerType:       HeaderType1,
+			packetType:       PacketTypeData,
+			transportType:    0x01, // Example
+			destType:         0x02, // Example
+			context:          ContextNone,
+			contextFlag:      FlagUnset,
+			dataSize:         100,
+			needsTransportID: false,
+		},
+		{
+			name:             "HeaderType2_Announce_ContextFlagSet",
+			headerType:       HeaderType2,
+			packetType:       PacketTypeAnnounce,
+			transportType:    0x01, // Changed from 0x0F (15) to 1 (valid 1-bit value)
+			destType:         0x01, // Example
+			context:          ContextResourceAdv,
+			contextFlag:      FlagSet,
+			dataSize:         50,
+			needsTransportID: true,
+		},
+		{
+			name:             "HeaderType1_EmptyData",
+			headerType:       HeaderType1,
+			packetType:       PacketTypeProof,
+			transportType:    0x00,
+			destType:         0x00,
+			context:          ContextLRProof,
+			contextFlag:      FlagSet,
+			dataSize:         0,
+			needsTransportID: false,
+		},
+		{
+			name:             "HeaderType2_MaxHops", // Hops are set manually before pack
+			headerType:       HeaderType2,
+			packetType:       PacketTypeLinkReq,
+			transportType:    0x01, // Changed from 0x05 (5) to 1 (valid 1-bit value)
+			destType:         0x03,
+			context:          ContextLinkIdentify,
+			contextFlag:      FlagUnset,
+			dataSize:         200,
+			needsTransportID: true,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			originalData := randomBytes(tc.dataSize)
+			originalDestHash := randomBytes(16) // Truncated dest hash
+			var originalTransportID []byte
+			if tc.needsTransportID {
+				originalTransportID = randomBytes(16)
+			}
+
+			p := &Packet{
+				HeaderType:      tc.headerType,
+				PacketType:      tc.packetType,
+				TransportType:   tc.transportType,
+				Context:         tc.context,
+				ContextFlag:     tc.contextFlag,
+				Hops:            5, // Example hops
+				DestinationType: tc.destType,
+				DestinationHash: originalDestHash,
+				TransportID:     originalTransportID,
+				Data:            originalData,
+				Packed:          false,
+			}
+
+			// Test Pack
+			err := p.Pack()
+			if err != nil {
+				t.Fatalf("Pack() failed: %v", err)
+			}
+			if !p.Packed {
+				t.Error("Pack() did not set Packed flag to true")
+			}
+			if len(p.Raw) == 0 {
+				t.Error("Pack() resulted in empty Raw data")
+			}
+
+			// Create a new packet from the raw data for unpacking
+			unpackTarget := &Packet{Raw: p.Raw}
+
+			// Test Unpack
+			err = unpackTarget.Unpack()
+			if err != nil {
+				t.Fatalf("Unpack() failed: %v", err)
+			}
+
+			// Verify unpacked fields match original
+			if unpackTarget.HeaderType != tc.headerType {
+				t.Errorf("Unpacked HeaderType = %d; want %d", unpackTarget.HeaderType, tc.headerType)
+			}
+			if unpackTarget.PacketType != tc.packetType {
+				t.Errorf("Unpacked PacketType = %d; want %d", unpackTarget.PacketType, tc.packetType)
+			}
+			if unpackTarget.TransportType != tc.transportType {
+				t.Errorf("Unpacked TransportType = %d; want %d", unpackTarget.TransportType, tc.transportType)
+			}
+			if unpackTarget.Context != tc.context {
+				t.Errorf("Unpacked Context = %d; want %d", unpackTarget.Context, tc.context)
+			}
+			if unpackTarget.ContextFlag != tc.contextFlag {
+				t.Errorf("Unpacked ContextFlag = %d; want %d", unpackTarget.ContextFlag, tc.contextFlag)
+			}
+			if unpackTarget.Hops != 5 { // Should match the Hops set before packing
+				t.Errorf("Unpacked Hops = %d; want %d", unpackTarget.Hops, 5)
+			}
+			if unpackTarget.DestinationType != tc.destType {
+				t.Errorf("Unpacked DestinationType = %d; want %d", unpackTarget.DestinationType, tc.destType)
+			}
+			if !bytes.Equal(unpackTarget.DestinationHash, originalDestHash) {
+				t.Errorf("Unpacked DestinationHash = %x; want %x", unpackTarget.DestinationHash, originalDestHash)
+			}
+			if !bytes.Equal(unpackTarget.Data, originalData) {
+				t.Errorf("Unpacked Data = %x; want %x", unpackTarget.Data, originalData)
+			}
+
+			if tc.needsTransportID {
+				if !bytes.Equal(unpackTarget.TransportID, originalTransportID) {
+					t.Errorf("Unpacked TransportID = %x; want %x", unpackTarget.TransportID, originalTransportID)
+				}
+			} else {
+				if unpackTarget.TransportID != nil {
+					t.Errorf("Unpacked TransportID = %x; want nil", unpackTarget.TransportID)
+				}
+			}
+		})
+	}
+}
+
+func TestPackMTUExceeded(t *testing.T) {
+	p := &Packet{
+		HeaderType:      HeaderType1,
+		PacketType:      PacketTypeData,
+		DestinationHash: randomBytes(16),
+		Context:         ContextNone,
+		Data:            randomBytes(MTU + 10), // Exceed MTU
+	}
+	err := p.Pack()
+	if err == nil {
+		t.Errorf("Pack() should have failed due to exceeding MTU, but it didn't")
+	}
+}
+
+func TestUnpackTooShort(t *testing.T) {
+	testCases := []struct {
+		name string
+		raw  []byte
+	}{
+		{"VeryShort", []byte{0x01}},
+		{"HeaderType1MinShort", []byte{0x00, 0x05, 0x01, 0x02}}, // Missing parts of dest hash
+		{"HeaderType2MinShort", []byte{0x40, 0x05, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10}}, // Missing dest hash
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			p := &Packet{Raw: tc.raw}
+			err := p.Unpack()
+			if err == nil {
+				t.Errorf("Unpack() should have failed for short packet, but it didn't")
+			}
+		})
+	}
+}
+
+func TestPacketHashing(t *testing.T) {
+	// Create two identical packets
+	data := randomBytes(50)
+	destHash := randomBytes(16)
+	p1 := &Packet{
+		HeaderType:      HeaderType1,
+		PacketType:      PacketTypeData,
+		TransportType:   0x01,
+		Context:         ContextNone,
+		ContextFlag:     FlagUnset,
+		Hops:            2,
+		DestinationType: 0x02,
+		DestinationHash: destHash,
+		Data:            data,
+	}
+	p2 := &Packet{
+		HeaderType:      HeaderType1,
+		PacketType:      PacketTypeData,
+		TransportType:   0x01,
+		Context:         ContextNone,
+		ContextFlag:     FlagUnset,
+		Hops:            2,
+		DestinationType: 0x02,
+		DestinationHash: destHash,
+		Data:            data,
+	}
+
+	// Pack both
+	if err := p1.Pack(); err != nil {
+		t.Fatalf("p1.Pack() failed: %v", err)
+	}
+	if err := p2.Pack(); err != nil {
+		t.Fatalf("p2.Pack() failed: %v", err)
+	}
+
+	// Hashes should be identical
+	hash1 := p1.GetHash()
+	hash2 := p2.GetHash()
+	if !bytes.Equal(hash1, hash2) {
+		t.Errorf("Hashes of identical packets differ:\nHash1: %x\nHash2: %x", hash1, hash2)
+	}
+	if !bytes.Equal(p1.PacketHash, hash1) {
+		t.Errorf("p1.PacketHash (%x) does not match GetHash() (%x)", p1.PacketHash, hash1)
+	}
+
+	// Change a non-hashable field (hops) in p2
+	p2.Hops = 3
+	p2.Raw[1] = 3 // Need to modify Raw as Pack isn't called again
+	hash3 := p2.GetHash()
+	if !bytes.Equal(hash1, hash3) {
+		t.Errorf("Hash changed after modifying non-hashable Hops field:\nHash1: %x\nHash3: %x", hash1, hash3)
+	}
+
+	// Change a hashable field (data) in p2
+	p2.Data = append(p2.Data, 0x99)
+	p2.Raw = append(p2.Raw, 0x99) // Modify Raw to reflect data change
+	hash4 := p2.GetHash()
+	if bytes.Equal(hash1, hash4) {
+		t.Errorf("Hash did not change after modifying hashable Data field")
+	}
+
+	// Test HeaderType2 hashing difference
+	p3 := &Packet{
+		HeaderType:      HeaderType2,
+		PacketType:      PacketTypeData,
+		TransportType:   0x01,
+		Context:         ContextNone,
+		ContextFlag:     FlagUnset,
+		Hops:            2,
+		DestinationType: 0x02,
+		DestinationHash: destHash,
+		TransportID:     randomBytes(16),
+		Data:            data,
+	}
+	if err := p3.Pack(); err != nil {
+		t.Fatalf("p3.Pack() failed: %v", err)
+	}
+	hash5 := p3.GetHash()
+	_ = hash5 // Use hash5 to avoid unused variable error
+}