Gandem · jorisjean · Dec 13, 2021
diff --git a/config.go b/config.go
@@ -11,6 +11,7 @@ type macAddress string
 type brconfig struct {
 	NetInterface string                       `toml:"net_interface"`
 	Devices      map[macAddress]bonjourDevice `toml:"devices"`
+	SpoofAddr    string                       `toml:"cc_subnet_ip"`
 }
 
 type bonjourDevice struct {

diff --git a/config_test.go b/config_test.go
@@ -20,6 +20,7 @@ func TestReadConfig(t *testing.T) {
 	expectedCfg := brconfig{
 		NetInterface: "test0",
 		Devices:      devices,
+		SpoofAddr:    "192.168.1.1",
 	}
 
 	if err != nil {

diff --git a/config_test.toml b/config_test.toml
@@ -1,5 +1,6 @@
 # This is a test config file used by config_test.go
 net_interface = "test0"
+cc_subnet_ip = "192.168.1.1"
 
 [devices]
 

diff --git a/main.go b/main.go
@@ -35,6 +35,12 @@ func main() {
 	if err != nil {
 		log.Fatalf("Could not find network interface: %v", cfg.NetInterface)
 	}
+
+	// Parse IP use to relay queries to chromecasts
+	spoofAddr := net.ParseIP(cfg.SpoofAddr)
+	if spoofAddr == nil {
+		log.Fatalf("Could not parse cc_subnet_ip")
+	}
 
 	// Get the local MAC address, to filter out Bonjour packet generated locally
 	intf, err := net.InterfaceByName(cfg.NetInterface)
@@ -66,15 +72,15 @@ func main() {
 				continue
 			}
 			for _, tag := range tags {
-				sendBonjourPacket(rawTraffic, &bonjourPacket, tag, brMACAddress)
+				sendBonjourPacket(rawTraffic, &bonjourPacket, tag, brMACAddress, spoofAddr, true)
 			}
 		} else {
 			device, ok := cfg.Devices[macAddress(bonjourPacket.srcMAC.String())]
 			if !ok {
 				continue
 			}
 			for _, tag := range device.SharedPools {
-				sendBonjourPacket(rawTraffic, &bonjourPacket, tag, brMACAddress)
+				sendBonjourPacket(rawTraffic, &bonjourPacket, tag, brMACAddress, spoofAddr, false)
 			}
 		}
 	}

diff --git a/packet.go b/packet.go
@@ -12,6 +12,7 @@ type bonjourPacket struct {
 	srcMAC     *net.HardwareAddr
 	dstMAC     *net.HardwareAddr
 	isIPv6     bool
+	srcIP     *net.IP
 	vlanTag    *uint16
 	isDNSQuery bool
 }
@@ -30,22 +31,23 @@ func parsePacketsLazily(source *gopacket.PacketSource) chan bonjourPacket {
 
 			// Get source and destination mac addresses
 			srcMAC, dstMAC := parseEthernetLayer(packet)
-
-			// Check IP protocol version
-			isIPv6 := parseIPLayer(packet)
-
+			
+			// Check IP protocol version and get srcIP
+			isIPv6, srcIP := parseIPLayer(packet)
+			
 			// Get UDP payload
 			payload := parseUDPLayer(packet)
 
 			isDNSQuery := parseDNSPayload(payload)
 
 			// Pass on the packet for its next adventure
 			packetChan <- bonjourPacket{
-				packet:     packet,
+			packet:     packet,
 				vlanTag:    tag,
 				srcMAC:     srcMAC,
 				dstMAC:     dstMAC,
 				isIPv6:     isIPv6,
+				srcIP:     srcIP,
 				isDNSQuery: isDNSQuery,
 			}
 		}
@@ -69,12 +71,14 @@ func parseVLANTag(packet gopacket.Packet) (tag *uint16) {
 	return
 }
 
-func parseIPLayer(packet gopacket.Packet) (isIPv6 bool) {
+func parseIPLayer(packet gopacket.Packet) (isIPv6 bool, srcIP *net.IP) {
 	if parsedIP := packet.Layer(layers.LayerTypeIPv4); parsedIP != nil {
 		isIPv6 = false
+		srcIP = &parsedIP.(*layers.IPv4).SrcIP
 	}
 	if parsedIP := packet.Layer(layers.LayerTypeIPv6); parsedIP != nil {
 		isIPv6 = true
+		srcIP = &parsedIP.(*layers.IPv6).SrcIP
 	}
 	return
 }
@@ -98,19 +102,35 @@ type packetWriter interface {
 	WritePacketData([]byte) error
 }
 
-func sendBonjourPacket(handle packetWriter, bonjourPacket *bonjourPacket, tag uint16, brMACAddress net.HardwareAddr) {
+func sendBonjourPacket(handle packetWriter, bonjourPacket *bonjourPacket, tag uint16, brMACAddress net.HardwareAddr, spoofAddr net.IP, spoof bool) {
 	*bonjourPacket.vlanTag = tag
 	*bonjourPacket.srcMAC = brMACAddress
-
+	
 	// Network devices may set dstMAC to the local MAC address
 	// Rewrite dstMAC to ensure that it is set to the appropriate multicast MAC address
 	if bonjourPacket.isIPv6 {
 		*bonjourPacket.dstMAC = net.HardwareAddr{0x33, 0x33, 0x00, 0x00, 0x00, 0xFB}
 	} else {
 		*bonjourPacket.dstMAC = net.HardwareAddr{0x01, 0x00, 0x5E, 0x00, 0x00, 0xFB}
 	}
-
+
+
 	buf := gopacket.NewSerializeBuffer()
-	gopacket.SerializePacket(buf, gopacket.SerializeOptions{}, bonjourPacket.packet)
+	serializeOptions := gopacket.SerializeOptions{}
+
+	// We change the Source IP address of the mDNS query since Chromecasts ignore
+	// packets coming from outside their subnet.
+	if spoof && bonjourPacket.isIPv6 == false {
+		serializeOptions = gopacket.SerializeOptions{ComputeChecksums: true}
+		*bonjourPacket.srcIP = spoofAddr
+		// We recalculate the checksum since the IP was modified
+		if parsedIP := bonjourPacket.packet.Layer(layers.LayerTypeIPv4); parsedIP != nil {
+			if parsedUDP := bonjourPacket.packet.Layer(layers.LayerTypeUDP); parsedUDP != nil {
+				parsedUDP.(*layers.UDP).SetNetworkLayerForChecksum(parsedIP.(*layers.IPv4))
+			}
+		}
+	}
+
+	gopacket.SerializePacket(buf, serializeOptions, bonjourPacket.packet)
 	handle.WritePacketData(buf.Bytes())
 }
diff --git a/packet_test.go b/packet_test.go
@@ -24,6 +24,7 @@ var (
 	dstUDPPortTest      = layers.UDPPort(5353)
 	questionPayloadTest = []byte{0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 7, 101, 120, 97,
 		109, 112, 108, 101, 3, 99, 111, 109, 0, 0, 1, 0, 1}
+	spoofAddrTest       = net.IP{192, 168, 1, 1}
 )
 
 func createMockmDNSPacket(isIPv4 bool, isDNSQuery bool) []byte {
@@ -150,16 +151,16 @@ func TestParseIPLayer(t *testing.T) {
 	isIPv4 := true
 	ipv4Packet := gopacket.NewPacket(createMockmDNSPacket(isIPv4, true), decoder, options)
 
-	computedIsIPv6 := parseIPLayer(ipv4Packet)
-	if computedIsIPv6 == true {
+	computedIsIPv6, srcIP := parseIPLayer(ipv4Packet)
+	if computedIsIPv6 == true || srcIP == nil {
 		t.Error("Error in parseIPLayer() for IPv4 addresses")
 	}
 
 	isIPv4 = false
 	ipv6Packet := gopacket.NewPacket(createMockmDNSPacket(isIPv4, true), decoder, options)
 
-	computedIsIPv6 = parseIPLayer(ipv6Packet)
-	if computedIsIPv6 == false {
+	computedIsIPv6, srcIP = parseIPLayer(ipv6Packet)
+	if computedIsIPv6 == false || srcIP == nil {
 		t.Error("Error in parseIPLayer() for IPv6 addresses")
 	}
 }
@@ -284,23 +285,27 @@ func TestSendBonjourPacket(t *testing.T) {
 	initialPacketIPv6 := gopacket.NewPacket(initialDataIPv6, decoder, gopacket.DecodeOptions{Lazy: true})
 
 	srcMACv4, dstMACv4 := parseEthernetLayer(initialPacketIPv4)
+	isIPv6, srcIP := parseIPLayer(initialPacketIPv4)
 	bonjourTestPacketIPv4 := bonjourPacket{
 		packet:     initialPacketIPv4,
 		vlanTag:    parseVLANTag(initialPacketIPv4),
 		srcMAC:     srcMACv4,
 		dstMAC:     dstMACv4,
+		srcIP:     srcIP,
 		isDNSQuery: true,
-		isIPv6:     false,
+		isIPv6:     isIPv6,
 	}
 
 	srcMACv6, dstMACv6 := parseEthernetLayer(initialPacketIPv6)
+	isIPv6, srcIP = parseIPLayer(initialPacketIPv6)
 	bonjourTestPacketIPv6 := bonjourPacket{
 		packet:     initialPacketIPv6,
 		vlanTag:    parseVLANTag(initialPacketIPv6),
 		srcMAC:     srcMACv6,
 		dstMAC:     dstMACv6,
+		srcIP:     srcIP,
 		isDNSQuery: true,
-		isIPv6:     true,
+		isIPv6:     isIPv6,
 	}
 
 	newVlanTag := uint16(29)
@@ -315,12 +320,18 @@ func TestSendBonjourPacket(t *testing.T) {
 
 	pw := &mockPacketWriter{packet: nil}
 
-	sendBonjourPacket(pw, &bonjourTestPacketIPv4, newVlanTag, brMACTest)
+	sendBonjourPacket(pw, &bonjourTestPacketIPv4, newVlanTag, brMACTest, spoofAddrTest, false)
 	if !reflect.DeepEqual(expectedPacketIPv4.Layers(), pw.packet.Layers()) {
 		t.Error("Error in sendBonjourPacket() for IPv4")
 	}
+
+	// When we change the src IP address of mDNS Query we expect the IPv4 layer to be different
+	sendBonjourPacket(pw, &bonjourTestPacketIPv4, newVlanTag, brMACTest, spoofAddrTest, true)
+	if reflect.DeepEqual(expectedPacketIPv4.Layers(), pw.packet.Layers()) {
+		t.Error("Error in sendBonjourPacket() for IPv4 with spoof address")
+	}
 
-	sendBonjourPacket(pw, &bonjourTestPacketIPv6, newVlanTag, brMACTest)
+	sendBonjourPacket(pw, &bonjourTestPacketIPv6, newVlanTag, brMACTest, spoofAddrTest, false)
 	if !reflect.DeepEqual(expectedPacketIPv6.Layers(), pw.packet.Layers()) {
 		t.Error("Error in sendBonjourPacket() for IPv6")
 	}