先说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
