2019-03-28 00:30:25 +00:00
|
|
|
package tuntap
|
2018-02-12 18:19:31 +00:00
|
|
|
|
2018-06-12 21:45:53 +00:00
|
|
|
// The ICMPv6 module implements functions to easily create ICMPv6
|
|
|
|
// packets. These functions, when mixed with the built-in Go IPv6
|
|
|
|
// and ICMP libraries, can be used to send control messages back
|
|
|
|
// to the host. Examples include:
|
|
|
|
// - NDP messages, when running in TAP mode
|
|
|
|
// - Packet Too Big messages, when packets exceed the session MTU
|
|
|
|
// - Destination Unreachable messages, when a session prohibits
|
|
|
|
// incoming traffic
|
2018-02-12 18:19:31 +00:00
|
|
|
|
2018-06-12 22:50:08 +00:00
|
|
|
import (
|
|
|
|
"encoding/binary"
|
|
|
|
"errors"
|
|
|
|
"net"
|
2019-07-06 14:08:17 +00:00
|
|
|
"sync"
|
2018-11-10 17:32:03 +00:00
|
|
|
"time"
|
2018-06-12 22:50:08 +00:00
|
|
|
|
|
|
|
"golang.org/x/net/icmp"
|
|
|
|
"golang.org/x/net/ipv6"
|
2018-12-15 02:49:18 +00:00
|
|
|
|
|
|
|
"github.com/yggdrasil-network/yggdrasil-go/src/address"
|
2018-06-12 22:50:08 +00:00
|
|
|
)
|
2018-02-12 18:19:31 +00:00
|
|
|
|
2018-05-27 22:31:34 +00:00
|
|
|
const len_ETHER = 14
|
2018-02-12 18:19:31 +00:00
|
|
|
|
2019-03-28 00:30:25 +00:00
|
|
|
type ICMPv6 struct {
|
2019-07-06 14:08:17 +00:00
|
|
|
tun *TunAdapter
|
|
|
|
mylladdr net.IP
|
|
|
|
mymac net.HardwareAddr
|
|
|
|
peermacs map[address.Address]neighbor
|
|
|
|
peermacsmutex sync.RWMutex
|
2018-11-10 17:32:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
type neighbor struct {
|
2019-07-06 14:08:17 +00:00
|
|
|
mac net.HardwareAddr
|
2018-11-10 17:32:03 +00:00
|
|
|
learned bool
|
|
|
|
lastadvertisement time.Time
|
|
|
|
lastsolicitation time.Time
|
2018-02-12 18:19:31 +00:00
|
|
|
}
|
|
|
|
|
2018-02-14 11:21:23 +00:00
|
|
|
// Marshal returns the binary encoding of h.
|
|
|
|
func ipv6Header_Marshal(h *ipv6.Header) ([]byte, error) {
|
|
|
|
b := make([]byte, 40)
|
|
|
|
b[0] |= byte(h.Version) << 4
|
|
|
|
b[0] |= byte(h.TrafficClass) >> 4
|
|
|
|
b[1] |= byte(h.TrafficClass) << 4
|
|
|
|
b[1] |= byte(h.FlowLabel >> 16)
|
|
|
|
b[2] = byte(h.FlowLabel >> 8)
|
|
|
|
b[3] = byte(h.FlowLabel)
|
|
|
|
binary.BigEndian.PutUint16(b[4:6], uint16(h.PayloadLen))
|
|
|
|
b[6] = byte(h.NextHeader)
|
|
|
|
b[7] = byte(h.HopLimit)
|
|
|
|
copy(b[8:24], h.Src)
|
|
|
|
copy(b[24:40], h.Dst)
|
|
|
|
return b, nil
|
2018-02-12 18:19:31 +00:00
|
|
|
}
|
|
|
|
|
2018-06-12 21:45:53 +00:00
|
|
|
// Initialises the ICMPv6 module by assigning our link-local IPv6 address and
|
|
|
|
// our MAC address. ICMPv6 messages will always appear to originate from these
|
|
|
|
// addresses.
|
2019-03-28 00:30:25 +00:00
|
|
|
func (i *ICMPv6) Init(t *TunAdapter) {
|
2018-02-12 18:19:31 +00:00
|
|
|
i.tun = t
|
2019-07-06 14:08:17 +00:00
|
|
|
i.peermacsmutex.Lock()
|
2018-12-15 02:49:18 +00:00
|
|
|
i.peermacs = make(map[address.Address]neighbor)
|
2019-07-06 14:08:17 +00:00
|
|
|
i.peermacsmutex.Unlock()
|
2018-02-14 11:21:23 +00:00
|
|
|
|
|
|
|
// Our MAC address and link-local address
|
2019-07-06 14:08:17 +00:00
|
|
|
i.mymac = net.HardwareAddr{
|
2018-11-10 15:46:10 +00:00
|
|
|
0x02, 0x00, 0x00, 0x00, 0x00, 0x02}
|
2018-02-14 11:21:23 +00:00
|
|
|
i.mylladdr = net.IP{
|
2018-02-12 18:19:31 +00:00
|
|
|
0xFE, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
2018-02-14 11:21:23 +00:00
|
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xFE}
|
2019-03-28 00:30:25 +00:00
|
|
|
copy(i.mymac[:], i.tun.addr[:])
|
|
|
|
copy(i.mylladdr[9:], i.tun.addr[1:])
|
2018-02-12 18:19:31 +00:00
|
|
|
}
|
|
|
|
|
2018-06-12 21:45:53 +00:00
|
|
|
// Parses an incoming ICMPv6 packet. The packet provided may be either an
|
|
|
|
// ethernet frame containing an IP packet, or the IP packet alone. This is
|
|
|
|
// determined by whether the TUN/TAP adapter is running in TUN (layer 3) or
|
2019-07-20 15:13:54 +00:00
|
|
|
// TAP (layer 2) mode. Returns an error condition which is nil if the ICMPv6
|
|
|
|
// module handled the packet or contains the error if not.
|
|
|
|
func (i *ICMPv6) ParsePacket(datain []byte) error {
|
2018-02-12 20:00:55 +00:00
|
|
|
var response []byte
|
|
|
|
var err error
|
|
|
|
|
2018-02-14 11:21:23 +00:00
|
|
|
// Parse the frame/packet
|
2019-03-28 00:30:25 +00:00
|
|
|
if i.tun.IsTAP() {
|
|
|
|
response, err = i.UnmarshalPacketL2(datain)
|
2018-02-12 20:00:55 +00:00
|
|
|
} else {
|
2019-03-28 00:30:25 +00:00
|
|
|
response, err = i.UnmarshalPacket(datain, nil)
|
2018-02-12 20:00:55 +00:00
|
|
|
}
|
2018-02-14 11:21:23 +00:00
|
|
|
|
2018-02-12 20:00:55 +00:00
|
|
|
if err != nil {
|
2019-07-20 15:13:54 +00:00
|
|
|
return err
|
2018-02-12 20:00:55 +00:00
|
|
|
}
|
2018-02-14 11:21:23 +00:00
|
|
|
|
|
|
|
// Write the packet to TUN/TAP
|
2019-03-28 09:12:00 +00:00
|
|
|
i.tun.iface.Write(response)
|
2019-07-20 15:13:54 +00:00
|
|
|
return nil
|
2018-02-12 18:19:31 +00:00
|
|
|
}
|
|
|
|
|
2018-06-12 21:45:53 +00:00
|
|
|
// Unwraps the ethernet headers of an incoming ICMPv6 packet and hands off
|
2019-03-28 00:30:25 +00:00
|
|
|
// the IP packet to the ParsePacket function for further processing.
|
2018-06-12 21:45:53 +00:00
|
|
|
// A response buffer is also created for the response message, also complete
|
|
|
|
// with ethernet headers.
|
2019-03-28 00:30:25 +00:00
|
|
|
func (i *ICMPv6) UnmarshalPacketL2(datain []byte) ([]byte, error) {
|
2018-02-12 18:19:31 +00:00
|
|
|
// Ignore non-IPv6 frames
|
2018-02-14 11:21:23 +00:00
|
|
|
if binary.BigEndian.Uint16(datain[12:14]) != uint16(0x86DD) {
|
2019-07-20 15:13:54 +00:00
|
|
|
return nil, errors.New("Ignoring non-IPv6 frame")
|
2018-02-12 18:19:31 +00:00
|
|
|
}
|
|
|
|
|
2019-03-28 00:30:25 +00:00
|
|
|
// Hand over to ParsePacket to interpret the IPv6 packet
|
2018-11-10 15:46:10 +00:00
|
|
|
mac := datain[6:12]
|
2019-03-28 00:30:25 +00:00
|
|
|
ipv6packet, err := i.UnmarshalPacket(datain[len_ETHER:], &mac)
|
2018-02-12 19:40:13 +00:00
|
|
|
if err != nil {
|
2018-02-14 11:21:23 +00:00
|
|
|
return nil, err
|
2018-02-12 19:40:13 +00:00
|
|
|
}
|
|
|
|
|
2018-02-14 11:21:23 +00:00
|
|
|
// Create the response buffer
|
2018-05-27 22:31:34 +00:00
|
|
|
dataout := make([]byte, len_ETHER+ipv6.HeaderLen+32)
|
2018-02-12 18:19:31 +00:00
|
|
|
|
2018-02-14 11:21:23 +00:00
|
|
|
// Populate the response ethernet headers
|
|
|
|
copy(dataout[:6], datain[6:12])
|
|
|
|
copy(dataout[6:12], i.mymac[:])
|
|
|
|
binary.BigEndian.PutUint16(dataout[12:14], uint16(0x86DD))
|
|
|
|
|
|
|
|
// Copy the returned packet to our response ethernet frame
|
2018-05-27 22:31:34 +00:00
|
|
|
copy(dataout[len_ETHER:], ipv6packet)
|
2018-02-14 11:21:23 +00:00
|
|
|
return dataout, nil
|
2018-02-12 18:19:31 +00:00
|
|
|
}
|
|
|
|
|
2018-06-12 21:45:53 +00:00
|
|
|
// Unwraps the IP headers of an incoming IPv6 packet and performs various
|
|
|
|
// sanity checks on the packet - i.e. is the packet an ICMPv6 packet, does the
|
|
|
|
// ICMPv6 message match a known expected type. The relevant handler function
|
|
|
|
// is then called and a response packet may be returned.
|
2019-03-28 00:30:25 +00:00
|
|
|
func (i *ICMPv6) UnmarshalPacket(datain []byte, datamac *[]byte) ([]byte, error) {
|
2018-02-14 11:21:23 +00:00
|
|
|
// Parse the IPv6 packet headers
|
|
|
|
ipv6Header, err := ipv6.ParseHeader(datain[:ipv6.HeaderLen])
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
2018-02-12 18:19:31 +00:00
|
|
|
}
|
|
|
|
|
2018-02-14 11:21:23 +00:00
|
|
|
// Check if the packet is IPv6
|
|
|
|
if ipv6Header.Version != ipv6.Version {
|
2019-07-20 15:13:54 +00:00
|
|
|
return nil, errors.New("Ignoring non-IPv6 packet")
|
2018-02-12 18:19:31 +00:00
|
|
|
}
|
|
|
|
|
2018-02-14 11:21:23 +00:00
|
|
|
// Check if the packet is ICMPv6
|
|
|
|
if ipv6Header.NextHeader != 58 {
|
2019-07-20 15:13:54 +00:00
|
|
|
return nil, errors.New("Ignoring non-ICMPv6 packet")
|
2018-02-14 11:21:23 +00:00
|
|
|
}
|
2018-02-12 18:19:31 +00:00
|
|
|
|
2018-02-14 11:21:23 +00:00
|
|
|
// Parse the ICMPv6 message contents
|
|
|
|
icmpv6Header, err := icmp.ParseMessage(58, datain[ipv6.HeaderLen:])
|
2018-02-12 19:40:13 +00:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
2018-02-14 11:21:23 +00:00
|
|
|
// Check for a supported message type
|
|
|
|
switch icmpv6Header.Type {
|
|
|
|
case ipv6.ICMPTypeNeighborSolicitation:
|
2019-03-28 00:30:25 +00:00
|
|
|
if !i.tun.IsTAP() {
|
2018-12-26 22:45:21 +00:00
|
|
|
return nil, errors.New("Ignoring Neighbor Solicitation in TUN mode")
|
|
|
|
}
|
2019-03-28 00:30:25 +00:00
|
|
|
response, err := i.HandleNDP(datain[ipv6.HeaderLen:])
|
2018-11-10 15:46:10 +00:00
|
|
|
if err == nil {
|
|
|
|
// Create our ICMPv6 response
|
2019-03-28 00:30:25 +00:00
|
|
|
responsePacket, err := CreateICMPv6(
|
2018-11-10 15:46:10 +00:00
|
|
|
ipv6Header.Src, i.mylladdr,
|
|
|
|
ipv6.ICMPTypeNeighborAdvertisement, 0,
|
|
|
|
&icmp.DefaultMessageBody{Data: response})
|
|
|
|
if err != nil {
|
2018-02-14 11:21:23 +00:00
|
|
|
return nil, err
|
|
|
|
}
|
2018-11-10 15:46:10 +00:00
|
|
|
// Send it back
|
|
|
|
return responsePacket, nil
|
|
|
|
} else {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
case ipv6.ICMPTypeNeighborAdvertisement:
|
2019-03-28 00:30:25 +00:00
|
|
|
if !i.tun.IsTAP() {
|
2018-12-26 22:45:21 +00:00
|
|
|
return nil, errors.New("Ignoring Neighbor Advertisement in TUN mode")
|
|
|
|
}
|
2018-11-10 15:46:10 +00:00
|
|
|
if datamac != nil {
|
2018-12-15 02:49:18 +00:00
|
|
|
var addr address.Address
|
2018-12-26 11:51:21 +00:00
|
|
|
var target address.Address
|
2019-07-06 14:08:17 +00:00
|
|
|
mac := net.HardwareAddr{0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
|
2018-11-10 15:46:10 +00:00
|
|
|
copy(addr[:], ipv6Header.Src[:])
|
2018-12-26 11:51:21 +00:00
|
|
|
copy(target[:], datain[48:64])
|
2018-11-10 15:46:10 +00:00
|
|
|
copy(mac[:], (*datamac)[:])
|
2019-07-06 14:08:17 +00:00
|
|
|
i.peermacsmutex.Lock()
|
2018-12-26 11:51:21 +00:00
|
|
|
neighbor := i.peermacs[target]
|
2018-11-10 17:32:03 +00:00
|
|
|
neighbor.mac = mac
|
|
|
|
neighbor.learned = true
|
|
|
|
neighbor.lastadvertisement = time.Now()
|
2018-12-26 12:25:28 +00:00
|
|
|
i.peermacs[target] = neighbor
|
2019-07-06 14:08:17 +00:00
|
|
|
i.peermacsmutex.Unlock()
|
|
|
|
i.tun.log.Debugln("Learned peer MAC", mac.String(), "for", net.IP(target[:]).String())
|
|
|
|
/*
|
|
|
|
i.tun.log.Debugln("Peer MAC table:")
|
|
|
|
i.peermacsmutex.RLock()
|
|
|
|
for t, n := range i.peermacs {
|
|
|
|
if n.learned {
|
|
|
|
i.tun.log.Debugln("- Target", net.IP(t[:]).String(), "has MAC", n.mac.String())
|
|
|
|
} else {
|
|
|
|
i.tun.log.Debugln("- Target", net.IP(t[:]).String(), "is not learned yet")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
i.peermacsmutex.RUnlock()
|
|
|
|
*/
|
2018-02-14 11:21:23 +00:00
|
|
|
}
|
2018-11-10 15:46:10 +00:00
|
|
|
return nil, errors.New("No response needed")
|
2018-02-14 11:21:23 +00:00
|
|
|
}
|
|
|
|
|
2018-02-15 13:38:54 +00:00
|
|
|
return nil, errors.New("ICMPv6 type not matched")
|
2018-02-12 18:19:31 +00:00
|
|
|
}
|
|
|
|
|
2018-06-12 21:45:53 +00:00
|
|
|
// Creates an ICMPv6 packet based on the given icmp.MessageBody and other
|
|
|
|
// parameters, complete with ethernet and IP headers, which can be written
|
|
|
|
// directly to a TAP adapter.
|
2019-07-06 14:08:17 +00:00
|
|
|
func (i *ICMPv6) CreateICMPv6L2(dstmac net.HardwareAddr, dst net.IP, src net.IP, mtype ipv6.ICMPType, mcode int, mbody icmp.MessageBody) ([]byte, error) {
|
2019-03-28 00:30:25 +00:00
|
|
|
// Pass through to CreateICMPv6
|
|
|
|
ipv6packet, err := CreateICMPv6(dst, src, mtype, mcode, mbody)
|
2018-02-14 11:39:55 +00:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
2018-02-14 11:46:10 +00:00
|
|
|
// Create the response buffer
|
2018-05-27 22:31:34 +00:00
|
|
|
dataout := make([]byte, len_ETHER+len(ipv6packet))
|
2018-02-14 11:39:55 +00:00
|
|
|
|
2018-02-14 11:46:10 +00:00
|
|
|
// Populate the response ethernet headers
|
|
|
|
copy(dataout[:6], dstmac[:6])
|
|
|
|
copy(dataout[6:12], i.mymac[:])
|
|
|
|
binary.BigEndian.PutUint16(dataout[12:14], uint16(0x86DD))
|
2018-02-14 11:39:55 +00:00
|
|
|
|
2018-02-14 11:46:10 +00:00
|
|
|
// Copy the returned packet to our response ethernet frame
|
2018-05-27 22:31:34 +00:00
|
|
|
copy(dataout[len_ETHER:], ipv6packet)
|
2018-02-14 11:46:10 +00:00
|
|
|
return dataout, nil
|
2018-02-14 11:39:55 +00:00
|
|
|
}
|
|
|
|
|
2018-06-12 21:45:53 +00:00
|
|
|
// Creates an ICMPv6 packet based on the given icmp.MessageBody and other
|
|
|
|
// parameters, complete with IP headers only, which can be written directly to
|
2019-03-28 00:30:25 +00:00
|
|
|
// a TUN adapter, or called directly by the CreateICMPv6L2 function when
|
2018-06-12 21:45:53 +00:00
|
|
|
// generating a message for TAP adapters.
|
2019-03-28 00:30:25 +00:00
|
|
|
func CreateICMPv6(dst net.IP, src net.IP, mtype ipv6.ICMPType, mcode int, mbody icmp.MessageBody) ([]byte, error) {
|
2018-02-14 11:21:23 +00:00
|
|
|
// Create the ICMPv6 message
|
|
|
|
icmpMessage := icmp.Message{
|
|
|
|
Type: mtype,
|
|
|
|
Code: mcode,
|
2018-02-14 22:59:24 +00:00
|
|
|
Body: mbody,
|
2018-02-14 11:21:23 +00:00
|
|
|
}
|
2018-02-12 18:19:31 +00:00
|
|
|
|
2018-02-15 13:38:54 +00:00
|
|
|
// Convert the ICMPv6 message into []byte
|
2018-03-10 22:31:36 +00:00
|
|
|
icmpMessageBuf, err := icmpMessage.Marshal(icmp.IPv6PseudoHeader(src, dst))
|
2018-02-12 18:19:31 +00:00
|
|
|
if err != nil {
|
2018-02-14 11:21:23 +00:00
|
|
|
return nil, err
|
2018-02-12 18:19:31 +00:00
|
|
|
}
|
|
|
|
|
2018-02-15 13:38:54 +00:00
|
|
|
// Create the IPv6 header
|
|
|
|
ipv6Header := ipv6.Header{
|
|
|
|
Version: ipv6.Version,
|
|
|
|
NextHeader: 58,
|
|
|
|
PayloadLen: len(icmpMessageBuf),
|
|
|
|
HopLimit: 255,
|
2018-03-10 22:31:36 +00:00
|
|
|
Src: src,
|
2018-02-15 13:38:54 +00:00
|
|
|
Dst: dst,
|
|
|
|
}
|
|
|
|
|
|
|
|
// Convert the IPv6 header into []byte
|
|
|
|
ipv6HeaderBuf, err := ipv6Header_Marshal(&ipv6Header)
|
2018-02-12 18:19:31 +00:00
|
|
|
if err != nil {
|
2018-02-14 11:21:23 +00:00
|
|
|
return nil, err
|
2018-02-12 18:19:31 +00:00
|
|
|
}
|
2018-02-12 19:40:13 +00:00
|
|
|
|
2018-02-14 11:21:23 +00:00
|
|
|
// Construct the packet
|
|
|
|
responsePacket := make([]byte, ipv6.HeaderLen+ipv6Header.PayloadLen)
|
|
|
|
copy(responsePacket[:ipv6.HeaderLen], ipv6HeaderBuf)
|
|
|
|
copy(responsePacket[ipv6.HeaderLen:], icmpMessageBuf)
|
|
|
|
|
|
|
|
// Send it back
|
|
|
|
return responsePacket, nil
|
2018-02-12 18:19:31 +00:00
|
|
|
}
|
|
|
|
|
2019-07-06 14:08:17 +00:00
|
|
|
func (i *ICMPv6) Solicit(addr address.Address) {
|
|
|
|
retries := 5
|
|
|
|
for retries > 0 {
|
|
|
|
retries--
|
|
|
|
i.peermacsmutex.RLock()
|
|
|
|
if n, ok := i.peermacs[addr]; ok && n.learned {
|
|
|
|
i.tun.log.Debugln("MAC learned for", net.IP(addr[:]).String())
|
|
|
|
i.peermacsmutex.RUnlock()
|
|
|
|
return
|
|
|
|
}
|
|
|
|
i.peermacsmutex.RUnlock()
|
|
|
|
i.tun.log.Debugln("Sending neighbor solicitation for", net.IP(addr[:]).String())
|
|
|
|
i.peermacsmutex.Lock()
|
|
|
|
if n, ok := i.peermacs[addr]; !ok {
|
|
|
|
i.peermacs[addr] = neighbor{
|
|
|
|
lastsolicitation: time.Now(),
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
n.lastsolicitation = time.Now()
|
|
|
|
}
|
|
|
|
i.peermacsmutex.Unlock()
|
|
|
|
request, err := i.createNDPL2(addr)
|
|
|
|
if err != nil {
|
|
|
|
panic(err)
|
|
|
|
}
|
|
|
|
if _, err := i.tun.iface.Write(request); err != nil {
|
|
|
|
panic(err)
|
|
|
|
}
|
|
|
|
i.tun.log.Debugln("Sent neighbor solicitation for", net.IP(addr[:]).String())
|
|
|
|
time.Sleep(time.Second)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-07-06 14:15:43 +00:00
|
|
|
func (i *ICMPv6) getNeighbor(addr address.Address) (neighbor, bool) {
|
|
|
|
i.peermacsmutex.RLock()
|
|
|
|
defer i.peermacsmutex.RUnlock()
|
|
|
|
|
|
|
|
n, ok := i.peermacs[addr]
|
|
|
|
return n, ok
|
|
|
|
}
|
|
|
|
|
2019-07-06 14:08:17 +00:00
|
|
|
func (i *ICMPv6) createNDPL2(dst address.Address) ([]byte, error) {
|
2018-11-10 15:46:10 +00:00
|
|
|
// Create the ND payload
|
|
|
|
var payload [28]byte
|
2019-07-06 14:08:17 +00:00
|
|
|
copy(payload[:4], []byte{0x00, 0x00, 0x00, 0x00}) // Flags
|
|
|
|
copy(payload[4:20], dst[:]) // Destination
|
|
|
|
copy(payload[20:22], []byte{0x01, 0x01}) // Type & length
|
|
|
|
copy(payload[22:28], i.mymac[:6]) // Link layer address
|
2018-11-10 15:46:10 +00:00
|
|
|
|
|
|
|
// Create the ICMPv6 solicited-node address
|
2018-12-15 02:49:18 +00:00
|
|
|
var dstaddr address.Address
|
2018-11-10 15:46:10 +00:00
|
|
|
copy(dstaddr[:13], []byte{
|
|
|
|
0xFF, 0x02, 0x00, 0x00,
|
|
|
|
0x00, 0x00, 0x00, 0x00,
|
|
|
|
0x00, 0x00, 0x00, 0x01, 0xFF})
|
2018-11-10 17:32:03 +00:00
|
|
|
copy(dstaddr[13:], dst[13:16])
|
2018-11-10 15:46:10 +00:00
|
|
|
|
|
|
|
// Create the multicast MAC
|
2019-07-06 14:08:17 +00:00
|
|
|
dstmac := net.HardwareAddr{0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
|
2018-11-10 15:46:10 +00:00
|
|
|
copy(dstmac[:2], []byte{0x33, 0x33})
|
|
|
|
copy(dstmac[2:6], dstaddr[12:16])
|
|
|
|
|
|
|
|
// Create the ND request
|
2019-03-28 00:30:25 +00:00
|
|
|
requestPacket, err := i.CreateICMPv6L2(
|
2018-11-10 15:46:10 +00:00
|
|
|
dstmac, dstaddr[:], i.mylladdr,
|
|
|
|
ipv6.ICMPTypeNeighborSolicitation, 0,
|
|
|
|
&icmp.DefaultMessageBody{Data: payload[:]})
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
return requestPacket, nil
|
|
|
|
}
|
|
|
|
|
2018-06-12 21:45:53 +00:00
|
|
|
// Generates a response to an NDP discovery packet. This is effectively called
|
|
|
|
// when the host operating system generates an NDP request for any address in
|
|
|
|
// the fd00::/8 range, so that the operating system knows to route that traffic
|
|
|
|
// to the Yggdrasil TAP adapter.
|
2019-03-28 00:30:25 +00:00
|
|
|
func (i *ICMPv6) HandleNDP(in []byte) ([]byte, error) {
|
2018-02-12 18:19:31 +00:00
|
|
|
// Ignore NDP requests for anything outside of fd00::/8
|
2018-12-15 02:49:18 +00:00
|
|
|
var source address.Address
|
2018-06-12 22:50:08 +00:00
|
|
|
copy(source[:], in[8:])
|
2018-12-15 02:49:18 +00:00
|
|
|
var snet address.Subnet
|
2018-06-12 22:50:08 +00:00
|
|
|
copy(snet[:], in[8:])
|
|
|
|
switch {
|
2018-12-15 02:49:18 +00:00
|
|
|
case source.IsValid():
|
|
|
|
case snet.IsValid():
|
2018-06-12 22:50:08 +00:00
|
|
|
default:
|
2018-06-15 10:02:45 +00:00
|
|
|
return nil, errors.New("Not an NDP for 0200::/7")
|
2018-02-12 18:19:31 +00:00
|
|
|
}
|
|
|
|
|
2018-02-14 11:21:23 +00:00
|
|
|
// Create our NDP message body response
|
2018-02-15 13:38:54 +00:00
|
|
|
body := make([]byte, 28)
|
2019-07-06 14:08:17 +00:00
|
|
|
binary.BigEndian.PutUint32(body[:4], uint32(0x40000000)) // Flags
|
|
|
|
copy(body[4:20], in[8:24]) // Target address
|
|
|
|
body[20] = uint8(2) // Type: Target link-layer address
|
|
|
|
body[21] = uint8(1) // Length: 1x address (8 bytes)
|
2018-02-14 11:21:23 +00:00
|
|
|
copy(body[22:28], i.mymac[:6])
|
2018-02-12 18:19:31 +00:00
|
|
|
|
2018-02-14 11:21:23 +00:00
|
|
|
// Send it back
|
|
|
|
return body, nil
|
2018-02-12 18:19:31 +00:00
|
|
|
}
|