scapy自定义packet field解析

先说scapy的数据包组成

scapy数据包有两个类，一个是packet，一个是field

Packet

packet类代表了一个完整的数据包

filed代表的是数据包中的成员

比如我有一个自定义的数据包如下

class MyFrame(Packet):
    name = "MyFrame"
    fields_desc = [
        ShortField("my_id", 0),
        ByteField("message_type", None),
        FieldLenField("len", None, length_of="data"),
        StrLenField("data", "", length_from=lambda pkt:pkt.len)
        ]

其中MyFrame继承自Packet，他由一堆field组成，这些filed可以是short,byte,int,str等类型，他们均继承自Field类，分别对应着不同的字节大小

Field

Field类代表的是packet的成员，可以认为是数据包的最小组成单元，在成帧的过程中，每一个filed输出一个bytes数组，然后packet按照顺序，把每个filed的bytes连接起来，形成最终的数据包

所以每个Field只需要关注自己输出的bytes数组就可以了，这也体现了面向对象的封装隔离的原则

我们先来看看scapy内置的一些Field成帧是怎么输出的

class ShortField(Field):
    def __init__(self, name, default):
        Field.__init__(self, name, default, "H")
class IntField(Field):
    def __init__(self, name, default):
        Field.__init__(self, name, default, "I")

ShortField和IntField都是简单的继承了Field类，没有重写任何函数，看一下Field的成帧函数

class Field(six.with_metaclass(Field_metaclass, object)):
    def addfield(self, pkt, s, val):
        """Add an internal value  to a string"""
        return s+struct.pack(self.fmt, self.i2m(pkt,val))

• addfield是成帧函数，输出一个最终的bytes数组，输入参数如下
  • pkt: 本Field对象所属的Packet对象实例
  • s: Packet已经构建出的bytearray数组，即本Field之前的那些Field组成的bytearray,所以返回值一定是s + 自己的bytearray，如果自己是空，则只返回s
  • val: 定义Packet实例时传给自己的值，类型不确定

• 举例说明addfield参数如下(只说明s和val,pkt都是frame对象引用)

frame = MyFrame(my_id=1,message_type=0x01)
frame.data = 'hello every one'
frame.len = len(frame.data)

• my_id是ShortField，他的addfield参数如下

  • s : 空数组
  • value，1 数值类型
  • return: 00 01

• message_type是ByteField, 他的addfield参数如下

  • s: 00 01
  • val: 0x01
  • return 00 01 01

• len是FieldLenField，他的addfield参数如下

  • s: 00 01 01
  • val: 15
  • return 00 01 01 00 0f

• data是StrLenField，他的addfield参数如下

  • s: 00 01 01 00 0f
  • val : "hello every one"
  • return 00 01 01 00 0f 68 65 6c 6c 6f 20 65 76 65 72 79 20 6f 6e 65

自定义Field

自定义Field，只需要继承Field类，重写addfield和getfield函数就可以了

addfield函数是把对象变为bytearray，反过来，getfield即把bytearray变为对象

如下我要封装一个RecordField，记录姓名，身高，年龄

import struct
from scapy.packet import Packet
from scapy.fields import Field,ShortField
from scapy.utils import lhex, hexdump

def hexify(buffer):
    """
    Return a hexadecimal string encoding of input buffer
    """
    return ' '.join('%02x' % ord(c) for c in buffer)

class RecordField(Field):
    def __init__(self, name, default):
        Field.__init__(self,name, default)


    def addfield(self, pkt, s, val):
        name = bytearray(val['name']) + bytearray(1)
        height = val['height']
        age = val['age']

        return s + name + struct.pack("I",height) + struct.pack("H",age)

    def getfield(self, pkt, s):
        index = 0
        for b in bytearray(s):
            if b == 0x00:
                break
            else:
                index += 1
        result = {}
        result['name'] = s[:index]

        result['height'] = struct.unpack("I",s[index+1:index+5])[0]
        result['age'] = struct.unpack("H",s[index+5:index+7])[0]

        return s[index+7:],result


class MyFrame(Packet):
    name = "MyFrame"
    fields_desc = [
        ShortField("id", 0),
        RecordField("record",None)
    ]

frame = MyFrame(
    id = 100,
    record = {
        "name":"jobs",
        "height":180,
        "age":55
    }
)

frame.show()
print hexify(str(frame))
hexdump(frame)
print frame.fields_desc[1].getfield(frame,str(frame)[2:])

run

###[ MyFrame ]### 
  id        = 100
  record    = {'age': 55, 'name': 'jobs', 'height': 180}

00 64 6a 6f 62 73 00 b4 00 00 00 37 00
0000  00646A6F627300B40000003700       .djobs.....7.
('', {'age': 55, 'name': 'jobs', 'height': 180})

封包解析

00 64   #id=100
6a 6f 62 73 00  #record.name=jobs
b4 00 00 00     #record.height=180
37 00           #record.age=55

• 可以看到，最终的数据包按照我的意愿组织了起来
• 因为getfield是内部调用的函数，所以最后一行代码模拟了一下内部调用的过程，将str转为object