Include files from the "epan" directory and subdirectories thereof with
[obnox/wireshark/wip.git] / packet-ipsec.c
1 /* packet-ipsec.c
2  * Routines for IPsec/IPComp packet disassembly 
3  *
4  * $Id: packet-ipsec.c,v 1.37 2002/01/21 07:36:35 guy Exp $
5  *
6  * Ethereal - Network traffic analyzer
7  * By Gerald Combs <gerald@ethereal.com>
8  * Copyright 1998 Gerald Combs
9  * 
10  * This program is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU General Public License
12  * as published by the Free Software Foundation; either version 2
13  * of the License, or (at your option) any later version.
14  * 
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  * 
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
23  */
24
25 #ifdef HAVE_CONFIG_H
26 # include "config.h"
27 #endif
28
29 #include <stdio.h>
30
31 #ifdef HAVE_SYS_TYPES_H
32 # include <sys/types.h>
33 #endif
34
35 #ifdef HAVE_NETINET_IN_H
36 # include <netinet/in.h>
37 #endif
38
39 #include <string.h>
40 #include <glib.h>
41 #include <epan/packet.h>
42 #include "packet-ipsec.h"
43 #include "packet-ip.h"
44 #include <epan/resolv.h>
45 #include "ipproto.h"
46 #include "prefs.h"
47
48 /* Place AH payload in sub tree */
49 gboolean g_ah_payload_in_subtree = FALSE;
50
51 static int proto_ah = -1;
52 static int hf_ah_spi = -1;
53 static int hf_ah_sequence = -1;
54 static int proto_esp = -1;
55 static int hf_esp_spi = -1;
56 static int hf_esp_sequence = -1;
57 static int proto_ipcomp = -1;
58 static int hf_ipcomp_flags = -1;
59 static int hf_ipcomp_cpi = -1;
60
61 static gint ett_ah = -1;
62 static gint ett_esp = -1;
63 static gint ett_ipcomp = -1;
64
65 static dissector_handle_t data_handle;
66
67 struct newah {
68         guint8  ah_nxt;         /* Next Header */
69         guint8  ah_len;         /* Length of data + 1, in 32bit */
70         guint16 ah_reserve;     /* Reserved for future use */
71         guint32 ah_spi;         /* Security parameter index */
72         guint32 ah_seq;         /* Sequence number field */
73         /* variable size, 32bit bound*/ /* Authentication data */
74 };
75
76 struct newesp {
77         guint32 esp_spi;        /* ESP */
78         guint32 esp_seq;        /* Sequence number */
79         /*variable size*/               /* (IV and) Payload data */
80         /*variable size*/               /* padding */
81         /*8bit*/                        /* pad size */
82         /*8bit*/                        /* next header */
83         /*8bit*/                        /* next header */
84         /*variable size, 32bit bound*/  /* Authentication data */
85 };
86
87 struct ipcomp {
88         guint8 comp_nxt;        /* Next Header */
89         guint8 comp_flags;      /* Must be zero */
90         guint16 comp_cpi;       /* Compression parameter index */
91 };
92
93 /* well-known algorithm number (in CPI), from RFC2409 */
94 #define IPCOMP_OUI      1       /* vendor specific */
95 #define IPCOMP_DEFLATE  2       /* RFC2394 */
96 #define IPCOMP_LZS      3       /* RFC2395 */
97 #define IPCOMP_MAX      4
98
99 static const value_string cpi2val[] = {
100     { IPCOMP_OUI, "OUI" },
101     { IPCOMP_DEFLATE, "DEFLATE" },
102     { IPCOMP_LZS, "LZS" },
103     { 0, NULL },
104 };
105
106 #ifndef offsetof
107 #define offsetof(type, member)  ((size_t)(&((type *)0)->member))
108 #endif
109
110 static void
111 dissect_ah(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
112 {
113     proto_tree *next_tree;
114     guint8 nxt;
115     tvbuff_t *next_tvb;
116     int advance;
117
118     advance = dissect_ah_header(tvb, pinfo, tree, &nxt, &next_tree);
119     next_tvb = tvb_new_subset(tvb, advance, -1, -1);
120
121     if (g_ah_payload_in_subtree) {
122         col_set_writable(pinfo->cinfo, FALSE);
123     }
124
125     /* do lookup with the subdissector table */
126     if (!dissector_try_port(ip_dissector_table, nxt, next_tvb, pinfo, next_tree)) {
127       call_dissector(data_handle,next_tvb, pinfo, next_tree);
128     }
129 }
130
131 int
132 dissect_ah_header(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
133                   guint8 *nxt_p, proto_tree **next_tree_p)
134 {
135     proto_tree *ah_tree;
136     proto_item *ti;
137     struct newah ah;
138     int advance;
139
140     if (check_col(pinfo->cinfo, COL_PROTOCOL))
141         col_set_str(pinfo->cinfo, COL_PROTOCOL, "AH");
142     if (check_col(pinfo->cinfo, COL_INFO))
143         col_clear(pinfo->cinfo, COL_INFO);
144
145     tvb_memcpy(tvb, (guint8 *)&ah, 0, sizeof(ah)); 
146     advance = sizeof(ah) + ((ah.ah_len - 1) << 2);
147
148     if (check_col(pinfo->cinfo, COL_INFO)) {
149         col_add_fstr(pinfo->cinfo, COL_INFO, "AH (SPI=0x%08x)",
150             (guint32)ntohl(ah.ah_spi));
151     }
152
153     if (tree) {
154         /* !!! specify length */
155         ti = proto_tree_add_item(tree, proto_ah, tvb, 0, advance, FALSE);
156         ah_tree = proto_item_add_subtree(ti, ett_ah);
157
158         proto_tree_add_text(ah_tree, tvb,
159                             offsetof(struct newah, ah_nxt), 1,
160                             "Next Header: %s (0x%02x)",
161                             ipprotostr(ah.ah_nxt), ah.ah_nxt);
162         proto_tree_add_text(ah_tree, tvb,
163                             offsetof(struct newah, ah_len), 1,
164                             "Length: %u", (ah.ah_len + 2) << 2);
165         proto_tree_add_uint(ah_tree, hf_ah_spi, tvb,
166                             offsetof(struct newah, ah_spi), 4,
167                             (guint32)ntohl(ah.ah_spi));
168         proto_tree_add_uint(ah_tree, hf_ah_sequence, tvb,
169                             offsetof(struct newah, ah_seq), 4,
170                             (guint32)ntohl(ah.ah_seq));
171         proto_tree_add_text(ah_tree, tvb,
172                             sizeof(ah), (ah.ah_len - 1) << 2,
173                             "ICV");
174
175         if (next_tree_p != NULL) {
176             /* Decide where to place next protocol decode */
177             if (g_ah_payload_in_subtree) {
178                 *next_tree_p = ah_tree;
179             }
180             else {
181                 *next_tree_p = tree;
182             }
183         }
184     } else {
185         if (next_tree_p != NULL)
186             *next_tree_p = NULL;
187     }
188
189     if (nxt_p != NULL)
190         *nxt_p = ah.ah_nxt;
191
192     /* start of the new header (could be a extension header) */
193     return advance;
194 }
195
196 static void
197 dissect_esp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
198 {
199     proto_tree *esp_tree;
200     proto_item *ti;
201     struct newesp esp;
202
203     /*
204      * load the top pane info. This should be overwritten by
205      * the next protocol in the stack
206      */
207     if (check_col(pinfo->cinfo, COL_PROTOCOL))
208         col_set_str(pinfo->cinfo, COL_PROTOCOL, "ESP");
209     if (check_col(pinfo->cinfo, COL_INFO))
210         col_clear(pinfo->cinfo, COL_INFO);
211
212     tvb_memcpy(tvb, (guint8 *)&esp, 0, sizeof(esp)); 
213
214     if (check_col(pinfo->cinfo, COL_INFO)) {
215         col_add_fstr(pinfo->cinfo, COL_INFO, "ESP (SPI=0x%08x)",
216             (guint32)ntohl(esp.esp_spi));
217     }
218
219     /*
220      * populate a tree in the second pane with the status of the link layer
221      * (ie none)
222      */
223     if(tree) {
224         ti = proto_tree_add_item(tree, proto_esp, tvb, 0,
225                                  tvb_length(tvb), FALSE);
226         esp_tree = proto_item_add_subtree(ti, ett_esp);
227         proto_tree_add_uint(esp_tree, hf_esp_spi, tvb, 
228                             offsetof(struct newesp, esp_spi), 4,
229                             (guint32)ntohl(esp.esp_spi));
230         proto_tree_add_uint(esp_tree, hf_esp_sequence, tvb,
231                             offsetof(struct newesp, esp_seq), 4,
232                             (guint32)ntohl(esp.esp_seq));
233         call_dissector(data_handle,tvb_new_subset(tvb, sizeof(struct newesp),-1,tvb_reported_length_remaining(tvb,sizeof(struct newesp))), pinfo, esp_tree);
234     }
235 }
236
237 static void
238 dissect_ipcomp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
239 {
240     proto_tree *ipcomp_tree;
241     proto_item *ti;
242     struct ipcomp ipcomp;
243     char *p;
244
245     /*
246      * load the top pane info. This should be overwritten by
247      * the next protocol in the stack
248      */
249     if (check_col(pinfo->cinfo, COL_PROTOCOL))
250         col_set_str(pinfo->cinfo, COL_PROTOCOL, "IPComp");
251     if (check_col(pinfo->cinfo, COL_INFO))
252         col_clear(pinfo->cinfo, COL_INFO);
253
254     tvb_memcpy(tvb, (guint8 *)&ipcomp, 0, sizeof(ipcomp)); 
255
256     if (check_col(pinfo->cinfo, COL_INFO)) {
257         p = match_strval(ntohs(ipcomp.comp_cpi), cpi2val);
258         if (p == NULL) {
259             col_add_fstr(pinfo->cinfo, COL_INFO, "IPComp (CPI=0x%04x)",
260                 ntohs(ipcomp.comp_cpi));
261         } else
262             col_add_fstr(pinfo->cinfo, COL_INFO, "IPComp (CPI=%s)", p);
263     }
264
265     /*
266      * populate a tree in the second pane with the status of the link layer
267      * (ie none)
268      */
269     if (tree) {
270         ti = proto_tree_add_item(tree, proto_ipcomp, tvb, 0,
271             tvb_length(tvb), FALSE);
272         ipcomp_tree = proto_item_add_subtree(ti, ett_ipcomp);
273
274         proto_tree_add_text(ipcomp_tree, tvb,
275             offsetof(struct ipcomp, comp_nxt), 1,
276             "Next Header: %s (0x%02x)",
277             ipprotostr(ipcomp.comp_nxt), ipcomp.comp_nxt);
278         proto_tree_add_uint(ipcomp_tree, hf_ipcomp_flags, tvb,
279             offsetof(struct ipcomp, comp_flags), 1,
280             ipcomp.comp_flags);
281         proto_tree_add_uint(ipcomp_tree, hf_ipcomp_cpi, tvb, 
282             offsetof(struct ipcomp, comp_cpi), 2,
283             ntohs(ipcomp.comp_cpi));
284         call_dissector(data_handle,tvb_new_subset(tvb, sizeof(struct ipcomp), -1,tvb_reported_length_remaining(tvb,sizeof(struct ipcomp))),pinfo, ipcomp_tree);
285     }
286 }
287
288 void
289 proto_register_ipsec(void)
290 {
291
292   static hf_register_info hf_ah[] = {
293     { &hf_ah_spi,
294       { "SPI",          "ah.spi",       FT_UINT32,      BASE_HEX, NULL, 0x0,
295         "", HFILL }},
296     { &hf_ah_sequence,
297       { "Sequence",     "ah.sequence",  FT_UINT32,      BASE_HEX, NULL, 0x0,
298         "", HFILL }}
299   };
300
301   static hf_register_info hf_esp[] = {
302     { &hf_esp_spi,
303       { "SPI",          "esp.spi",      FT_UINT32,      BASE_HEX, NULL, 0x0,
304         "", HFILL }},
305     { &hf_esp_sequence,
306       { "Sequence",     "esp.sequence", FT_UINT32,      BASE_HEX, NULL, 0x0,
307         "", HFILL }}
308   };
309
310   static hf_register_info hf_ipcomp[] = {
311     { &hf_ipcomp_flags,
312       { "Flags",        "ipcomp.flags", FT_UINT8,       BASE_HEX, NULL, 0x0,
313         "", HFILL }},
314     { &hf_ipcomp_cpi,
315       { "CPI",          "ipcomp.cpi",   FT_UINT16,      BASE_HEX, 
316         VALS(cpi2val),  0x0,            "", HFILL }},
317   };
318   static gint *ett[] = {
319     &ett_ah,
320     &ett_esp,
321     &ett_ipcomp,
322   };
323
324   module_t *ah_module;
325
326   proto_ah = proto_register_protocol("Authentication Header", "AH", "ah");
327   proto_register_field_array(proto_ah, hf_ah, array_length(hf_ah));
328
329   proto_esp = proto_register_protocol("Encapsulating Security Payload",
330                                       "ESP", "esp");
331   proto_register_field_array(proto_esp, hf_esp, array_length(hf_esp));
332
333   proto_ipcomp = proto_register_protocol("IP Payload Compression",
334                                          "IPComp", "ipcomp");
335   proto_register_field_array(proto_ipcomp, hf_ipcomp, array_length(hf_ipcomp));
336
337   proto_register_subtree_array(ett, array_length(ett));
338
339   /* Register a configuration option for placement of AH payload dissection */
340   ah_module = prefs_register_protocol(proto_ah, NULL);
341   prefs_register_bool_preference(ah_module, "place_ah_payload_in_subtree",
342             "Place AH payload in subtree",
343 "Whether the AH payload decode should be placed in a subtree",
344             &g_ah_payload_in_subtree);
345
346   register_dissector("esp", dissect_esp, proto_esp);
347   register_dissector("ah", dissect_ah, proto_ah);
348 }
349
350 void
351 proto_reg_handoff_ipsec(void)
352 {
353   dissector_handle_t esp_handle, ah_handle, ipcomp_handle;
354
355   data_handle = find_dissector("data");
356   ah_handle = find_dissector("ah");
357   dissector_add("ip.proto", IP_PROTO_AH, ah_handle);
358   esp_handle = find_dissector("esp");
359   dissector_add("ip.proto", IP_PROTO_ESP, esp_handle);
360   ipcomp_handle = create_dissector_handle(dissect_ipcomp, proto_ipcomp);
361   dissector_add("ip.proto", IP_PROTO_IPCOMP, ipcomp_handle);
362 }