Squelch an MSVC++ complaint.
[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.33 2001/11/09 08:16:24 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 "packet.h"
42 #include "packet-ipsec.h"
43 #include "packet-ip.h"
44 #include "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 struct newah {
66         guint8  ah_nxt;         /* Next Header */
67         guint8  ah_len;         /* Length of data + 1, in 32bit */
68         guint16 ah_reserve;     /* Reserved for future use */
69         guint32 ah_spi;         /* Security parameter index */
70         guint32 ah_seq;         /* Sequence number field */
71         /* variable size, 32bit bound*/ /* Authentication data */
72 };
73
74 struct newesp {
75         guint32 esp_spi;        /* ESP */
76         guint32 esp_seq;        /* Sequence number */
77         /*variable size*/               /* (IV and) Payload data */
78         /*variable size*/               /* padding */
79         /*8bit*/                        /* pad size */
80         /*8bit*/                        /* next header */
81         /*8bit*/                        /* next header */
82         /*variable size, 32bit bound*/  /* Authentication data */
83 };
84
85 struct ipcomp {
86         guint8 comp_nxt;        /* Next Header */
87         guint8 comp_flags;      /* Must be zero */
88         guint16 comp_cpi;       /* Compression parameter index */
89 };
90
91 /* well-known algorithm number (in CPI), from RFC2409 */
92 #define IPCOMP_OUI      1       /* vendor specific */
93 #define IPCOMP_DEFLATE  2       /* RFC2394 */
94 #define IPCOMP_LZS      3       /* RFC2395 */
95 #define IPCOMP_MAX      4
96
97 static const value_string cpi2val[] = {
98     { IPCOMP_OUI, "OUI" },
99     { IPCOMP_DEFLATE, "DEFLATE" },
100     { IPCOMP_LZS, "LZS" },
101     { 0, NULL },
102 };
103
104 #ifndef offsetof
105 #define offsetof(type, member)  ((size_t)(&((type *)0)->member))
106 #endif
107
108 static void
109 dissect_ah(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
110 {
111     proto_tree *next_tree;
112     guint8 nxt;
113     tvbuff_t *next_tvb;
114     int advance;
115
116     advance = dissect_ah_header(tvb, pinfo, tree, &nxt, &next_tree);
117     next_tvb = tvb_new_subset(tvb, advance, -1, -1);
118
119     if (g_ah_payload_in_subtree) {
120         col_set_writable(pinfo->fd, FALSE);
121     }
122
123     /* do lookup with the subdissector table */
124     if (!dissector_try_port(ip_dissector_table, nxt, next_tvb, pinfo, next_tree)) {
125       dissect_data(next_tvb, 0, pinfo, next_tree);
126     }
127 }
128
129 int
130 dissect_ah_header(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
131                   guint8 *nxt_p, proto_tree **next_tree_p)
132 {
133     proto_tree *ah_tree;
134     proto_item *ti;
135     struct newah ah;
136     int advance;
137
138     if (check_col(pinfo->fd, COL_PROTOCOL))
139         col_set_str(pinfo->fd, COL_PROTOCOL, "AH");
140     if (check_col(pinfo->fd, COL_INFO))
141         col_clear(pinfo->fd, COL_INFO);
142
143     tvb_memcpy(tvb, (guint8 *)&ah, 0, sizeof(ah)); 
144     advance = sizeof(ah) + ((ah.ah_len - 1) << 2);
145
146     if (check_col(pinfo->fd, COL_INFO)) {
147         col_add_fstr(pinfo->fd, COL_INFO, "AH (SPI=0x%08x)",
148             (guint32)ntohl(ah.ah_spi));
149     }
150
151     if (tree) {
152         /* !!! specify length */
153         ti = proto_tree_add_item(tree, proto_ah, tvb, 0, advance, FALSE);
154         ah_tree = proto_item_add_subtree(ti, ett_ah);
155
156         proto_tree_add_text(ah_tree, tvb,
157                             offsetof(struct newah, ah_nxt), 1,
158                             "Next Header: %s (0x%02x)",
159                             ipprotostr(ah.ah_nxt), ah.ah_nxt);
160         proto_tree_add_text(ah_tree, tvb,
161                             offsetof(struct newah, ah_len), 1,
162                             "Length: %u", (ah.ah_len + 2) << 2);
163         proto_tree_add_uint(ah_tree, hf_ah_spi, tvb,
164                             offsetof(struct newah, ah_spi), 4,
165                             (guint32)ntohl(ah.ah_spi));
166         proto_tree_add_uint(ah_tree, hf_ah_sequence, tvb,
167                             offsetof(struct newah, ah_seq), 4,
168                             (guint32)ntohl(ah.ah_seq));
169         proto_tree_add_text(ah_tree, tvb,
170                             sizeof(ah), (ah.ah_len - 1) << 2,
171                             "ICV");
172
173         if (next_tree_p != NULL) {
174             /* Decide where to place next protocol decode */
175             if (g_ah_payload_in_subtree) {
176                 *next_tree_p = ah_tree;
177             }
178             else {
179                 *next_tree_p = tree;
180             }
181         }
182     } else {
183         if (next_tree_p != NULL)
184             *next_tree_p = NULL;
185     }
186
187     if (nxt_p != NULL)
188         *nxt_p = ah.ah_nxt;
189
190     /* start of the new header (could be a extension header) */
191     return advance;
192 }
193
194 static void
195 dissect_esp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
196 {
197     proto_tree *esp_tree;
198     proto_item *ti;
199     struct newesp esp;
200
201     /*
202      * load the top pane info. This should be overwritten by
203      * the next protocol in the stack
204      */
205     if (check_col(pinfo->fd, COL_PROTOCOL))
206         col_set_str(pinfo->fd, COL_PROTOCOL, "ESP");
207     if (check_col(pinfo->fd, COL_INFO))
208         col_clear(pinfo->fd, COL_INFO);
209
210     tvb_memcpy(tvb, (guint8 *)&esp, 0, sizeof(esp)); 
211
212     if (check_col(pinfo->fd, COL_INFO)) {
213         col_add_fstr(pinfo->fd, COL_INFO, "ESP (SPI=0x%08x)",
214             (guint32)ntohl(esp.esp_spi));
215     }
216
217     /*
218      * populate a tree in the second pane with the status of the link layer
219      * (ie none)
220      */
221     if(tree) {
222         ti = proto_tree_add_item(tree, proto_esp, tvb, 0,
223                                  tvb_length(tvb), FALSE);
224         esp_tree = proto_item_add_subtree(ti, ett_esp);
225         proto_tree_add_uint(esp_tree, hf_esp_spi, tvb, 
226                             offsetof(struct newesp, esp_spi), 4,
227                             (guint32)ntohl(esp.esp_spi));
228         proto_tree_add_uint(esp_tree, hf_esp_sequence, tvb,
229                             offsetof(struct newesp, esp_seq), 4,
230                             (guint32)ntohl(esp.esp_seq));
231         dissect_data(tvb, sizeof(struct newesp), pinfo, esp_tree);
232     }
233 }
234
235 static void
236 dissect_ipcomp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
237 {
238     proto_tree *ipcomp_tree;
239     proto_item *ti;
240     struct ipcomp ipcomp;
241     char *p;
242
243     /*
244      * load the top pane info. This should be overwritten by
245      * the next protocol in the stack
246      */
247     if (check_col(pinfo->fd, COL_PROTOCOL))
248         col_set_str(pinfo->fd, COL_PROTOCOL, "IPComp");
249     if (check_col(pinfo->fd, COL_INFO))
250         col_clear(pinfo->fd, COL_INFO);
251
252     tvb_memcpy(tvb, (guint8 *)&ipcomp, 0, sizeof(ipcomp)); 
253
254     if (check_col(pinfo->fd, COL_INFO)) {
255         p = match_strval(ntohs(ipcomp.comp_cpi), cpi2val);
256         if (p == NULL) {
257             col_add_fstr(pinfo->fd, COL_INFO, "IPComp (CPI=0x%04x)",
258                 ntohs(ipcomp.comp_cpi));
259         } else
260             col_add_fstr(pinfo->fd, COL_INFO, "IPComp (CPI=%s)", p);
261     }
262
263     /*
264      * populate a tree in the second pane with the status of the link layer
265      * (ie none)
266      */
267     if (tree) {
268         ti = proto_tree_add_item(tree, proto_ipcomp, tvb, 0,
269             tvb_length(tvb), FALSE);
270         ipcomp_tree = proto_item_add_subtree(ti, ett_ipcomp);
271
272         proto_tree_add_text(ipcomp_tree, tvb,
273             offsetof(struct ipcomp, comp_nxt), 1,
274             "Next Header: %s (0x%02x)",
275             ipprotostr(ipcomp.comp_nxt), ipcomp.comp_nxt);
276         proto_tree_add_uint(ipcomp_tree, hf_ipcomp_flags, tvb,
277             offsetof(struct ipcomp, comp_flags), 1,
278             ipcomp.comp_flags);
279         proto_tree_add_uint(ipcomp_tree, hf_ipcomp_cpi, tvb, 
280             offsetof(struct ipcomp, comp_cpi), 2,
281             ntohs(ipcomp.comp_cpi));
282         dissect_data(tvb, sizeof(struct ipcomp), pinfo, ipcomp_tree);
283     }
284 }
285
286 void
287 proto_register_ipsec(void)
288 {
289
290   static hf_register_info hf_ah[] = {
291     { &hf_ah_spi,
292       { "SPI",          "ah.spi",       FT_UINT32,      BASE_HEX, NULL, 0x0,
293         "", HFILL }},
294     { &hf_ah_sequence,
295       { "Sequence",     "ah.sequence",  FT_UINT32,      BASE_HEX, NULL, 0x0,
296         "", HFILL }}
297   };
298
299   static hf_register_info hf_esp[] = {
300     { &hf_esp_spi,
301       { "SPI",          "esp.spi",      FT_UINT32,      BASE_HEX, NULL, 0x0,
302         "", HFILL }},
303     { &hf_esp_sequence,
304       { "Sequence",     "esp.sequence", FT_UINT32,      BASE_HEX, NULL, 0x0,
305         "", HFILL }}
306   };
307
308   static hf_register_info hf_ipcomp[] = {
309     { &hf_ipcomp_flags,
310       { "Flags",        "ipcomp.flags", FT_UINT8,       BASE_HEX, NULL, 0x0,
311         "", HFILL }},
312     { &hf_ipcomp_cpi,
313       { "CPI",          "ipcomp.cpi",   FT_UINT16,      BASE_HEX, 
314         VALS(cpi2val),  0x0,            "", HFILL }},
315   };
316   static gint *ett[] = {
317     &ett_ah,
318     &ett_esp,
319     &ett_ipcomp,
320   };
321
322   module_t *ah_module;
323
324   proto_ah = proto_register_protocol("Authentication Header", "AH", "ah");
325   proto_register_field_array(proto_ah, hf_ah, array_length(hf_ah));
326
327   proto_esp = proto_register_protocol("Encapsulating Security Payload",
328                                       "ESP", "esp");
329   proto_register_field_array(proto_esp, hf_esp, array_length(hf_esp));
330
331   proto_ipcomp = proto_register_protocol("IP Payload Compression",
332                                          "IPComp", "ipcomp");
333   proto_register_field_array(proto_ipcomp, hf_ipcomp, array_length(hf_ipcomp));
334
335   proto_register_subtree_array(ett, array_length(ett));
336
337   /* Register a configuration option for placement of AH payload dissection */
338   ah_module = prefs_register_protocol(proto_ah, NULL);
339   prefs_register_bool_preference(ah_module, "place_ah_payload_in_subtree",
340             "Place AH payload in subtree",
341 "Whether the AH payload decode should be placed in a subtree",
342             &g_ah_payload_in_subtree);
343
344   register_dissector("esp", dissect_esp, proto_esp);
345   register_dissector("ah", dissect_ah, proto_ah);
346 }
347
348 void
349 proto_reg_handoff_ipsec(void)
350 {
351   dissector_add("ip.proto", IP_PROTO_AH, dissect_ah, proto_ah);
352   dissector_add("ip.proto", IP_PROTO_ESP, dissect_esp, proto_esp);
353   dissector_add("ip.proto", IP_PROTO_IPCOMP, dissect_ipcomp, proto_ipcomp);
354 }