使用 lua 编写 wireshark 协议解析插件

1 struct foo
2 {
3     char protocol_type[16];     /* request response notify */
4     char service_type[16];      /* 我们定义的各种服务类型 */
5     unsigned int msg_len;       /* 消息体的长度 */
6     char msg_content[0];        /* 消息体的内容，由于是变长的所以采用此方法定义 */
7 };

 1 do
 2     --[[
 3         创建一个新的协议结构 foo_proto
 4         第一个参数是协议名称会体现在过滤器中
 5         第二个参数是协议的描述信息，无关紧要
 6     --]]
 7     local foo_proto = Proto("foo", "Foo Protolcol")
 8     
 9     --[[
10         下面定义字段
11     --]]
12     local foo_protocol_type = ProtoField.string("foo.prototype", "Protocol Type", base.NONE)
13     local foo_service_type = ProtoField.string("foo.servicetype", "Service Type", base.NONE)
14     local foo_msg_len = ProtoField.uint32("foo.msglen", "Message Length", base.DEC)
15     local foo_msg_content = ProtoField.string("foo.msgcontent", "Message Content", base.NONE)
16     
17     -- 将字段添加都协议中
18     foo_proto.fields = {
19         foo_protocol_type,
20         foo_service_type,
21         foo_msg_len,
22         foo_msg_content
23     }
24     
25     --[[
26         下面定义 foo 解析器的主函数，这个函数由 wireshark调用
27         第一个参数是 Tvb 类型，表示的是需要此解析器解析的数据
28         第二个参数是 Pinfo 类型，是协议解析树上的信息，包括 UI 上的显示
29         第三个参数是 TreeItem 类型，表示上一级解析树
30     --]]
31     function foo_proto.dissector(tvb, pinfo, treeitem)
32         
33         -- 设置一些 UI 上面的信息
34         pinfo.cols.protocol:set("FOO")
35         pinfo.cols.info:set("Foo Protocol")
36         
37         local offset = 0
38         local tvb_len = tvb:len()
39         
40         -- 在上一级解析树上创建 foo 的根节点
41         local foo_tree = treeitem:add(foo_proto, tvb:range(offset))
42         
43         -- 下面是想该根节点上添加子节点，也就是自定义协议的各个字段
44         -- 注意 range 这个方法的两个参数的意义，第一个表示此时的偏移量
45         -- 第二个参数代表的是字段占用数据的长度
46         foo_tree:add(foo_protocol_type, tvb:range(offset, 16))
47         offset = offset+16        
48         foo_tree:add(foo_service_type, tvb:range(offset, 16))
49         offset = offset+16
50         foo_tree:add(foo_msg_len, tvb:range(offset, 4))
51         offset = offset+4
52         
53         -- 计算消息内容的长度
54         local foo_content_len = tvb_len-offset
55         foo_tree:add(foo_msg_content, tvb:range(offset, foo_content_len))
56         offset = offset+foo_content_len
57         
58     end
59     
60     -- 向 wireshark 注册协议插件被调用的条件
61     local tcp_port_table = DissectorTable.get("tcp.port")
62     tcp_port_table:add(12345, foo_proto)
63 end

 1 do
 2     -- 这里便于运算需要将数据类型进行转换
 3     local tvbrange = tvb:range(0)
 4     local bytearray = tvbrange:bytes()
 5     local offset = pinfo.desegment_offset or 0
 6     
 7     while true do
 8         local pdu_flg = false
 9         local pdu_end_index = 0
10         
11         -- ByteArray 类型的索引与 C 类似
12         -- 这与 lua 本身处理表的方式有所区别
13         for i = offset, tvb_len do
14             if 0xFF == bytearray:get_index(i) then
15                 pdu_flg = true
16                 pdu_end_index = i
17             end
18         end
19         
20         -- 如果没有找到 PDU 的结束符，进行合包延迟解析
21         if false == frame_end_flg then
22             -- 如果明确知道这个应用协议还需要多少字节
23             -- 可以明确地将需要的值填上，而不是使用下面的值
24             -- 只是表示需要更多的分节
25             pinfo.desegment_len = DESEGMENT_ONE_MORE_SEGMENT
26             return
27         end
28         
29         -- 下面是正常的处理流程，在上面的代码中已经有体现了
30         -- 不过此时协议最大边界为 pdu_end_index
31         
32     end
33 end

1         local protocol_type = tvb:range(offset, 16):string()
2         foo_tree:add(foo_protocol_type, tvb:range(offset, 4), protocol_type)

1 local protocol_type = tvb:range(offset, 16):string()
2 foo_tree:add(tvb:range(offset, 16), "Protocol Type: " .. protocol_type)