Ticket #31: igmp.py

#! /usr/bin/env python


#------------------------------------------------------------------------------
#------------------------------------------------------------------------------
#
# See RFC2236, Section 2. Introduction for definitions of proper IGMPv2 message format
#   http://www.faqs.org/rfcs/rfc2236.html
#

igmptypes = { 0x11 : "Group Membership Query",
              0x12 : "Version 1 - Membership Report",
              0x16 : "Version 2 - Membership Report",
              0x17 : "Leave Group"}

class IGMP(Packet):
  """IGMP Message Class for v1 and v2.

  This class is derived from class Packet. You may need to "sanitize" the IP 
  and Ethernet headers before a full packet is sent.

  """
  name = "IGMP"
  fields_desc = [ ByteEnumField("type", 0x11, igmptypes),
                      ByteField("mrtime",0),
                    XShortField("chksum", None),
                        IPField("gaddr", "0.0.0.0")]

#------------------------------------------------------------------------------
  def post_build(self, p, pay):
    """Called implicitly before a packet is sent to compute and place IGMP checksum.

    Parameters:
      self    The instantiation of an IGMP class
      p       The IGMP message in hex in network byte order
      pay     Additional payload for the IGMP message
    """
    p += pay
    if self.chksum is None:
      ck = checksum(p)
      p = p[:2]+chr(ck>>8)+chr(ck&0xff)+p[4:]
    return p

#------------------------------------------------------------------------------
  def mysummary(self):
    """Display a summary of the IGMP object."""

    if isinstance(self.underlayer, IP):
      return self.underlayer.sprintf("IGMP: %IP.src% > %IP.dst% %IGMP.type% %IGMP.gaddr%")
    else:
      return self.sprintf("IGMP %IGMP.type% %IGMP.gaddr%")

#------------------------------------------------------------------------------
  def sanitize (self, ip=None, ether=None):
    """Called to explicitely fixup associated IP and Ethernet headers

    Parameters:
      self    The instantiation of an IGMP class.
      ip      The instantiation of the associated IP class.
      ether   The instantiation of the associated Ethernet.

    Returns:
      True    The tuple ether/ip/self passed all check and represents a proper
              IGMP packet.
      False   One of more validation checks failed and no fields were adjusted.

    The function will examine the IGMP message to assure proper format. 
    Corrections will be attempted if possible. The IP header is then properly 
    adjusted to ensure correct formatting and assignment. The Ethernet header
    is then adjusted to the proper IGMP packet format.
    """

# The rules are:
#   1.  the Max Response time is meaningful only in Membership Queries and should be zero 
#       otherwise (RFC 2236, section 2.2)
    if (self.type != 0x11):         #rule 1
      self.mrtime = 0
    if (self.adjust_ip(ip) == True):
      if (self.adjust_ether(ip, ether) == True): return True
    return False

#------------------------------------------------------------------------------
  def adjust_ether (self, ip=None, ether=None):
    """Called to explicitely fixup an associated Ethernet header

    Parameters:
      self    The instantiation of an IGMP class.
      ip      The instantiation of the associated IP class.
      ether   The instantiation of the associated Ethernet.

    Returns:
      True    The tuple ether/ip/self passed all check and represents a proper
              IGMP packet.
      False   One of more validation checks failed and no fields were adjusted.

    The function adjusts the ethernet header destination MAC address based on 
    the destination IP address.
    """
# The rules are:
#   1. send the packet to the group mac address address corresponding to the IP
    if ip != None and ip.haslayer(IP) and ether != None and ether.haslayer(Ether):
      ipaddr = socket.ntohl(atol(ip.dst)) & 0x007FFFFF
      macstr = "01:5e:00:%02x:%02x:%02x" %((ipaddr>>16)&0xFF, (ipaddr>>8)&0xFF, (ipaddr>>0)&0xFF)
      ether.dst=macstr
      return True
    else:
      return False

#------------------------------------------------------------------------------
  def adjust_ip (self, ip=None):
    """Called to explicitely fixup an associated IP header

    Parameters:
      self    The instantiation of an IGMP class.
      ip      The instantiation of the associated IP class.

    Returns:
      True    The tuple ip/self passed all checks and represents a proper
              IGMP packet.
      False   One of more validation checks failed and no fields were adjusted.

    The function adjusts the IP header based on conformance rules and the group
    address encoded in the IGMP message.
    """
# The rules are:
#   1. send the packet to the group address registering/reporting for 
#     a. for General Group Query, send packet to 224.0.0.1 (all systems)
#   2. send the packet with the router alert IP option (RFC 2236, section 2)
#   3. ttl = 1 (RFC 2236, section 2)
    if ip != None and ip.haslayer(IP):
      if (self.type == 0x11):
        if (self.gaddr == "0.0.0.0"):
          ip.dst = "224.0.0.1"
          retCode = True                     
        elif (atol(self.gaddr)&0xff >= 224) and (atol(self.gaddr)&0xff <= 239):
          ip.dst = self.gaddr
          retCode = True
        else:
          retCode = False
      elif ((self.type == 0x12) or (self.type == 0x16) or (self.type == 0x17)) and \
           (atol(self.gaddr)&0xff >= 224) and (atol(self.gaddr)&0xff <= 239):
          ip.dst = self.gaddr
          retCode = True
      elif (self.type == 0x22):
        ip.dst = "224.0.0.22"
        retCode = True
      elif (self.type == 0x30) or (self.type == 0x32):
        ip.dst = "224.0.0.106"
        retCode = True
      elif (self.type == 0x31):
        ip.dst = "224.0.0.2"
        retCode = True
      else:
        retCode = False
    else:
      retCode = False
    if retCode == True:
      ip.options="\x94\x04\x00\x00"   # set IP Router Alert option
    return retCode

#------------------------------------------------------------------------------
#------------------------------------------------------------------------------
#
# See RFC3376, Section 4. Message Formats for definitions of proper IGMPv3 message format
#   http://www.faqs.org/rfcs/rfc3376.html
#
# See RFC4286, For definitions of proper messages for Multicast Router Discovery.
#   http://www.faqs.org/rfcs/rfc4286.html
#

igmpv3grtypes = { 1 : "Mode Is Include",
                  2 : "Mode Is Exclude",
                  3 : "Change To Include Mode",
                  4 : "Change To Exclude Mode",
                  5 : "Allow New Sources",
                  6 : "Block Old Sources"}

class IGMPv3gr(Packet):
  """IGMP Group Record for IGMPv3 Membership Report

  This class is derived from class Packet and should be concatenated to an
  instantiation of class IGMPv3. Within the IGMPv3 instantiation, the numgrp
  element will need to be manipulated to indicate the proper number of
  group records.
  """
  name = "IGMPv3gr"
  fields_desc = [ ByteEnumField("rtype", 1, igmpv3grtypes),
                      ByteField("auxdlen",0),
                  FieldLenField("numsrc", None, "srcaddrs"),
                        IPField("maddr", "0.0.0.0"),
                 FieldListField("srcaddrs", None, IPField("sa", "0.0.0.0"), "numsrc") ]
  show_indent=0
#------------------------------------------------------------------------------
  def post_build(self, p, pay):
    """Called implicitly before a packet is sent.
    """
    p += pay
    if self.auxdlen != 0:
      print "NOTICE: A properly formatted and complaint V3 Group Record should have an Auxiliary Data length of zero (0)."
      print "        Subsequent Group Records are lost!"
    return p
#------------------------------------------------------------------------------
  def mysummary(self):
    """Display a summary of the IGMPv3 group record."""
    return self.sprintf("IGMPv3 Group Record %IGMPv3gr.type% %IGMPv3gr.maddr%")

igmpv3types = { 0x11 : "Membership Query",
                0x22 : "Version 3 Membership Report",
                0x30 : "Multicast Router Advertisement",
                0x31 : "Multicast Router Solicitation",
                0x32 : "Multicast Router Termination"}

class IGMPv3(IGMP):
  """IGMP Message Class for v3.

  This class is derived from class Packet. 
  The fields defined below are a 
  direct interpretation of the v3 Membership Query Message. 
  Fields 'type'  through 'qqic' are directly assignable. 
  For 'numsrc', do not assign a value. 
  Instead add to the 'srcaddrs' list to auto-set 'numsrc'. To 
  assign values to 'srcaddrs', use the following methods:
    c = IGMPv3()
    c.srcaddrs = ['1.2.3.4', '5.6.7.8']
    c.srcaddrs += ['192.168.10.24']
  At this point, 'c.numsrc' is three (3)

  'chksum' is automagically calculated before the packet is sent.

  'mrcode' is also the Advertisement Interval field

  """
  name = "IGMPv3"
  fields_desc = [ ByteEnumField("type", 0x11, igmpv3types),
                      ByteField("mrcode",0),              # use float_encode()
                    XShortField("chksum", None),
    # if type = 0x11 (Membership Query), the next field is group address 
       ConditionalField(IPField("gaddr", "0.0.0.0"), "type", lambda x:x==0x11),
    # else if type = 0x22 (Membership Report), the next fields are 
    #         reserved and number of group records
    ConditionalField(ShortField("rsvd2", 0), "type", lambda x:x==0x22),
    ConditionalField(ShortField("numgrp", 0), "type", lambda x:x==0x22),
#                  FieldLenField("numgrp", None, "grprecs")]
    # else if type = 0x30 (Multicast Router Advertisement), the next fields are 
    #         query interval and robustness
    ConditionalField(ShortField("qryIntvl", 0), "type", lambda x:x==0x30),
    ConditionalField(ShortField("robust", 0), "type", lambda x:x==0x30),
#  The following are only present for membership queries
          ConditionalField(BitField("resv", 0, 4), "type", lambda x:x==0x11),
          ConditionalField(BitField("s", 0, 1), "type", lambda x:x==0x11),
          ConditionalField(BitField("qrv", 0, 3), "type", lambda x:x==0x11), 
         ConditionalField(ByteField("qqic",0), "type", lambda x:x==0x11),
     ConditionalField(FieldLenField("numsrc", None, "srcaddrs"), "type", lambda x:x==0x11),
    ConditionalField(FieldListField("srcaddrs", None, IPField("sa", "0.0.0.0"), "numsrc"), "type", lambda x:x==0x11),
    ]

#------------------------------------------------------------------------------
  def float_encode(self, value):
    """Convert the integer value to its IGMPv3 encoded time value if needed.
   
    If value < 128, return the value specified. If >= 128, encode as a floating 
    point value. Value can be 0 - 31744.
    """
    if value < 128:
      code = value
    elif value > 31743:
      code = 255
    else:
      exp=0
      value>>=3
      while(value>31):
        exp+=1
        value>>=1
      exp<<=4
      code = 0x80 | exp | (value & 0x0F)
    return code

#------------------------------------------------------------------------------
  def post_build(self, p, pay):
    """Called implicitly before a packet is sent to compute and place IGMPv3 checksum.

    Parameters:
      self    The instantiation of an IGMPv3 class
      p       The IGMPv3 message in hex in network byte order
      pay     Additional payload for the IGMPv3 message
    """
    p += pay
    if self.type in [0, 0x31, 0x32, 0x22]:   # for these, field is reserved (0)
      p = p[:1]+chr(0)+p[2:]
    if self.chksum is None:
      ck = checksum(p)
      p = p[:2]+chr(ck>>8)+chr(ck&0xff)+p[4:]
    return p

#------------------------------------------------------------------------------
  def mysummary(self):
    """Display a summary of the IGMPv3 object."""

    if isinstance(self.underlayer, IP):
      return self.underlayer.sprintf("IGMPv3: %IP.src% > %IP.dst% %IGMPv3.type% %IGMPv3.gaddr%")
    else:
      return self.sprintf("IGMPv3 %IGMPv3.type% %IGMPv3.gaddr%")

# The rules are:
#   1.  ttl = 1 (RFC 2236, section 2)
igmp_binds = [ (IP, IGMP,   { "proto": 2 , "ttl": 1 }),
#   2.  tos = 0xC0 (RFC 3376, section 4)
               (IP, IGMPv3, { "proto": 2 , "ttl": 1, "tos":0xc0 }),
               (IGMPv3, IGMPv3gr, { }) ]

def test_igmp ():
  a=Ether()
  a.src="00:01:5a:29:00:AA"
  a.dst="00:01:23:45:67:89"
  b=IP()
  b.src="1.2.3.4"
  b.dst="5.6.7.8"
  c=IGMP()
  d=a/b/c
  print "Send a simple IGMP packet with no fixup"
  print "Ethernet, IP, IGMP"
  sendp(d, iface="eth1")
#
  c.sanitize(b, a)
  d=a/b/c
  print "Send a properly formatted General Query"
  print "DA = 01:5e:00:00:00:01, DIP=224.0.0.1, Router Alert Option Set"
  sendp(d, iface="eth1")
#
  c.gaddr="224.1.2.3"
  c.mrtime=30
  c.sanitize(b, a)
  d=a/b/c
  print "Send a properly formatted Group-Specific Query w/ Max response time = 3.0s"
  sendp(d, iface="eth1")
#
  c.gaddr="224.2.3.4"
  c.type=0x12
  c.chksum=0xabcd
  c.sanitize(b, a)
  d=a/b/c
  print "Send a properly formatted V1 membership report w/ bad checksum"
  sendp(d, iface="eth1")
#
  c.gaddr="224.3.4.5"
  c.type=0x16
  c.chksum=None
  c.mrtime=0xee
  c.sanitize(b, a)
  d=a/b/c
  print "Send a properly formatted V2 membership report"
  sendp(d, iface="eth1")
#
  c.gaddr="224.4.5.6"
  c.type=0x17
  c.sanitize(b, a)
  d=a/b/c
  print "Send a properly formatted leave group"
  sendp(d, iface="eth1")
  d.show()
  d.show2()
  d.mysummary()
#
def test_igmpv3 ():
  a=Ether()
  a.src="00:01:5a:29:00:AA"
  a.dst="00:01:23:45:67:89"
  b=IP()
  b.src="1.2.3.4"
  b.dst="5.6.7.8"
  c=IGMPv3()
  d=a/b/c
  print "Send a simple IGMPv3 packet"
  sendp(d, iface="eth1")
#
  c.sanitize(b, a)
  d=a/b/c
  print "Send a properly formatted V3 General Membership Query"
  print "DA = 01:5e:00:00:00:01, DIP=224.0.0.1, DSCP = 0x30, Router Alert Option Set"
  sendp(d, iface="eth1")
#
  c.gaddr="225.150.2.3"
  c.mrcode=c.float_encode(240)
  c.s=1
  c.qrv=3
  c.sanitize(b, a)
  d=a/b/c
  print "Send a properly formatted Group-Specific Query w/ Max response time = 24.0s"
  print "Suppress router-side processing, QRV=3"
  sendp(d, iface="eth1")
  d.show()
  d.show2()
  d.mysummary()
#
  b.src="0.0.0.0"
  c.gaddr="225.162.3.4"
  c.s=0
  c.qqic=c.float_encode(109)
  c.qrv=4
  c.srcaddrs = ['1.2.3.4', '5.6.7.8']
  c.sanitize(b, a)
  d=a/b/c
  print "Send a properly formatted Group/Source-Specific Query w/ QQIC = 109"
  print "DA = 01:5e:00:22:03:04, DIP=225.162.3.4, DSCP = 0x30, Router Alert Option Set"
  print "QRV=4, QQIC=109, Num Sources = 2 ('1.2.3.4' and '5.6.7.8')"
  sendp(d, iface="eth1")
#
  b.src="1.2.3.4"
  b.dst="225.163.4.5"
  c.type=0x22
  c.numgrp=3
  e=IGMPv3gr()
  e.rtype=3
  e.maddr="225.99.44.33"
  e.srcaddrs=["192.168.77.12"]
  e.srcaddrs+=["192.168.77.13"]
  f=IGMPv3gr()
  f.rtype=5
  f.maddr="228.200.77.88"
  f.srcaddrs=["192.168.77.14", "192.168.77.15"]
  g=IGMPv3gr()
  g.rtype=6
  g.maddr="229.190.191.192"
  g.auxdlen=2       
  g.add_payload("\x0f\x0e\x0d\x0c\x0b\x0a\x09\x08")
  c.sanitize(b, a)
  d=a/b/c/e/f/g
  print "Send a properly formatted V3 Membership Report. Three Group records, the last with auxilliary data"
  sendp(d, iface="eth1")
  d.show()
  d.show2()
  d.mysummary()
#
  b.dst="225.213.4.5"
  c.numgrp=0
  c.sanitize(b, a)
  d=a/b/c
  print "Send a properly formatted V3 Membership Report"
  sendp(d, iface="eth1")
#
  c.type=0x30
  c.mrcode=144
  c.qryIntvl=204
  c.robust=248
  c.sanitize(b, a)
  d=a/b/c
  print "Send a properly formatted V3 Multicast Router Advertisement"
  sendp(d, iface="eth1")
#
  c.type=0x31
  c.sanitize(b, a)
  d=a/b/c
  print "Send a properly formatted V3 Multicast Router Solicitation"
  sendp(d, iface="eth1")
#
  c.type=0x32
  c.sanitize(b, a)
  d=a/b/c
  print "Send a properly formatted V3 Multicast Router Termination"
  sendp(d, iface="eth1")
  d.show()
  d.show2()
  d.mysummary()