1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License, Version 1.0 only
6 * (the "License"). You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22 /*
23 * Copyright 2005 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 * Copyright 2012 Milan Jurik. All rights reserved.
26 */
27
28 #include <sys/types.h>
29 #include <sys/errno.h>
30 #include <sys/tiuser.h>
31 #include <setjmp.h>
32
33 #include <rpc/types.h>
34 #include <rpc/xdr.h>
35 #include <rpc/auth.h>
36 #include <rpc/clnt.h>
37 #include <rpc/rpc_msg.h>
38 #include <rpc/rpcsec_gss.h>
39 #include <string.h>
40 #include "snoop.h"
41
42 extern jmp_buf xdr_err;
43
44 struct cache_struct *find_xid();
45 char *nameof_prog(int prog);
46 static void print_rpc_gss_init_arg(int, struct cache_struct *);
47 static void print_rpc_gss_init_res(int);
48
49 char *
50 rpcsec_gss_proc_to_string(unsigned int proc)
51 {
52 switch (proc) {
53 case RPCSEC_GSS_DATA: return "RPCSEC_GSS_DATA"; break;
54 case RPCSEC_GSS_INIT: return "RPCSEC_GSS_INIT"; break;
55 case RPCSEC_GSS_CONTINUE_INIT:
56 return ("RPCSEC_GSS_CONTINUE_INIT");
57 case RPCSEC_GSS_DESTROY:
58 return ("RPCSEC_GSS_DESTROY");
59 default: return ("unknown");
60
61 }
62 }
63
64
65 char *
66 rpcsec_gss_service_to_string(rpc_gss_service_t service)
67 {
68 switch (service) {
69 case rpc_gss_svc_none: return "none"; break;
70 case rpc_gss_svc_integrity: return "integrity"; break;
71 case rpc_gss_svc_privacy: return "privacy"; break;
72 default: return "unknown"; break;
73
74 }
75 }
76
77 /*
78 * Print detailed RPCSEC_GSS cred data.
79 */
80 void
81 print_rpcsec_gss_cred(int xid, int authlen)
82 {
83 unsigned int seq_num;
84 unsigned int handle_len;
85 unsigned int rpcsec_gss_ver;
86 rpc_gss_service_t rpcsec_gss_service;
87 unsigned int rpcsec_gss_proc;
88 char *handle, *line;
89 struct cache_struct *x;
90 int pos;
91
92 pos = getxdr_pos();
93 rpcsec_gss_ver = getxdr_u_long();
94
95 /* see if we know this version or not */
96
97 if (rpcsec_gss_ver != 1) {
98 (void) showxdr_hex(authlen, "[%s]");
99 return;
100 }
101
102 rpcsec_gss_proc = getxdr_u_long();
103 seq_num = getxdr_u_long();
104 rpcsec_gss_service = getxdr_enum();
105
106 (void) sprintf(get_line(pos, getxdr_pos()),
107 " version = %u", rpcsec_gss_ver);
108
109 (void) sprintf(get_line(pos, getxdr_pos()),
110 " gss control procedure = %u (%s)",
111 rpcsec_gss_proc,
112 rpcsec_gss_proc_to_string(rpcsec_gss_proc));
113
114 (void) sprintf(get_line(pos, getxdr_pos()),
115 " sequence num = %u", seq_num);
116
117 (void) sprintf(get_line(pos, getxdr_pos()),
118 " service = %d (%s)", rpcsec_gss_service,
119 rpcsec_gss_service_to_string(rpcsec_gss_service));
120 pos = getxdr_pos();
121 handle_len = getxdr_u_long();
122 handle = getxdr_hex(handle_len);
123 line = get_line(pos, getxdr_pos());
124 sprintf(line, " handle: length = %d, data = [%s]",
125 handle_len, handle);
126 x = find_xid(xid);
127 if (x) {
128 x->xid_gss_proc = rpcsec_gss_proc;
129 x->xid_gss_service = rpcsec_gss_service;
130 }
131 }
132
133 /*
134 * Based on different RPCSEC_GSS services supported, maybe a
135 * special handling is needed before printing the arguments.
136 *
137 * For integrity service : print the sequence number.
138 * For privacy service : do not print the arguments.
139 */
140 int
141 rpcsec_gss_pre_proto(int type, int flags, int xid,
142 int prog, int vers, int proc)
143 {
144 int seq;
145 struct cache_struct *x;
146
147 if (! (x = find_xid(xid)))
148 return (0);
149
150 switch (x->xid_gss_service) {
151 case rpc_gss_svc_default:
152 case rpc_gss_svc_none:
153 break; /* standard call args */
154 case rpc_gss_svc_integrity:
155 /* length of rpc_gss_data_t encoded in the databody_integ */
156 getxdr_u_long();
157 /* read the seq number */
158 seq = getxdr_u_long();
159 if (flags & F_ALLSUM) {
160 (void) sprintf(get_sum_line(), "%s %c seq_num = %u",
161 "RPC RPCSEC_GSS", type == CALL ? 'C' : 'R',
162 seq);
163 } else if (flags & F_DTAIL) {
164 sprintf(get_line(0, 0),
165 "RPCSEC_GSS data seq_num = %u", seq);
166 show_space();
167 }
168 /* call args follow */
169 break;
170 case rpc_gss_svc_privacy: {
171 char *progname = nameof_prog(prog);
172 char prognum[32];
173
174 if (*progname == '?') {
175 sprintf(prognum, "%d", prog);
176 progname = prognum;
177 }
178
179 if (flags & F_SUM || flags & F_ALLSUM) {
180 (void) sprintf(get_sum_line(),
181 "%s %c %s ver(%d) proc(%d) (data encrypted) ",
182 "RPC RPCSEC_GSS", type == CALL ? 'C' : 'R',
183 progname, vers, proc);
184 } else if (flags & F_DTAIL) {
185 unsigned int args_len;
186
187 args_len = getxdr_u_long();
188 sprintf(get_line(0, 0),
189 "RPCSEC_GSS %s ver(%d) proc(%d)",
190 progname, vers, proc);
191 sprintf(get_line(0, 0),
192 "(%s args encrypted, len = %d bytes)",
193 type == CALL ? "CALL" : "REPLY", args_len);
194 show_space();
195 }
196 }
197 return (1);
198
199 default:
200 break;
201 }
202 return (0);
203 }
204
205 /*
206 * Based on different RPCSEC_GSS services supported, maybe a
207 * special handling is needed after printing the arguments.
208 *
209 * For integrity service : print the checksum.
210 */
211 void
212 rpcsec_gss_post_proto(int flags, int xid)
213 {
214 char *line;
215
216 struct cache_struct *x;
217
218 if (! (x = find_xid(xid)))
219 return;
220
221 switch (x->xid_gss_service) {
222 case rpc_gss_svc_default:
223 case rpc_gss_svc_none:
224 case rpc_gss_svc_privacy:
225 /* nothing left */
226 break;
227 case rpc_gss_svc_integrity:
228 if (flags & F_ALLSUM) {
229 line = get_sum_line();
230 sprintf(line, "RPC RPCSEC_GSS C (checksum)");
231 } else if (flags & F_DTAIL) {
232 unsigned int checksum_len;
233 char *checksum;
234
235 show_header("RPC: ", "RPCSEC_GSS", 0);
236 show_space();
237 checksum_len = getxdr_u_long();
238 checksum = getxdr_hex(checksum_len);
239 sprintf(get_line(0, 0),
240 "checksum: len = %d", checksum_len);
241 sprintf(get_line(0, 0), "[%s]", checksum);
242 show_trailer();
243 }
244 break;
245 default:
246 break;
247 }
248 }
249
250 /*
251 * Print RPCSEC_GSS control procedures protocol data,
252 * No-op for RPCSEC_GSS_DATA.
253 */
254 int
255 rpcsec_gss_control_proc(int type, int flags, int xid)
256 {
257 int seq;
258
259 struct cache_struct *x;
260
261 if (! (x = find_xid(xid)))
262 return (0);
263
264 if (x->xid_gss_proc != RPCSEC_GSS_DATA) {
265 if (flags & F_SUM) {
266 if (type == CALL) {
267 (void) sprintf(get_sum_line(), "%s %c %u (%s)",
268 "RPC RPCSEC_GSS",
269 type == CALL ? 'C' : 'R',
270 x->xid_gss_proc,
271 rpcsec_gss_proc_to_string(x->xid_gss_proc));
272 }
273 } else if (flags & F_DTAIL) {
274 if (x->xid_gss_proc == RPCSEC_GSS_INIT ||
275 x->xid_gss_proc == RPCSEC_GSS_CONTINUE_INIT) {
276 if (type == CALL) {
277 print_rpc_gss_init_arg(flags, x);
278 } else {
279 print_rpc_gss_init_res(flags);
280 }
281 }
282 }
283 return (1);
284 }
285
286 return (0);
287 }
288
289 /*
290 * Skip the header RPCSEC_GSS cred data and
291 * put service and control type in the xid cache.
292 */
293 void
294 extract_rpcsec_gss_cred_info(int xid)
295 {
296 unsigned int seq_num;
297 unsigned int handle_len;
298 unsigned int flavor_len;
299 unsigned int rpcsec_gss_ver;
300 rpc_gss_service_t rpcsec_gss_service;
301 unsigned int rpcsec_gss_proc;
302 struct cache_struct *x;
303
304 flavor_len = getxdr_u_long();
305 rpcsec_gss_ver = getxdr_u_long();
306 /* see if we know this version or not */
307 if (rpcsec_gss_ver != 1) {
308 longjmp(xdr_err, 1);
309 }
310 rpcsec_gss_proc = getxdr_u_long();
311 seq_num = getxdr_u_long();
312 rpcsec_gss_service = getxdr_enum();
313 /* skip the handle */
314 xdr_skip(RNDUP(getxdr_u_long()));
315
316 if (x = find_xid(xid)) {
317 x->xid_gss_service = rpcsec_gss_service;
318 x->xid_gss_proc = rpcsec_gss_proc;
319 }
320
321 }
322
323 /*
324 * Print the argument data for the RPCSEC_GSS_INIT control procedure.
325 */
326 static void
327 print_rpc_gss_init_arg(int flags, struct cache_struct *x)
328 {
329
330 char *token, *line;
331 unsigned int token_len;
332 int pos = 0;
333
334 /*
335 * see if we need to print out the rpc_gss_init_arg structure
336 * or not.
337 */
338
339 if (x->xid_gss_proc != RPCSEC_GSS_INIT &&
340 x->xid_gss_proc != RPCSEC_GSS_CONTINUE_INIT) {
341 return;
342 }
343
344 /* print it */
345
346 (void) sprintf(get_line(pos, getxdr_pos()),
347 "RPCSEC_GSS_INIT args:");
348
349 pos = getxdr_pos();
350 token_len = getxdr_u_long();
351 token = getxdr_hex(token_len);
352 line = get_line(pos, getxdr_pos());
353 sprintf(line, " gss token: length = %d, data = [%d bytes]",
354 token_len, token_len);
355
356 show_trailer();
357 }
358
359 /*
360 * Print the results data for the RPCSEC_GSS_INIT control procedure.
361 */
362 void
363 print_rpc_gss_init_res(int flags)
364 {
365
366 char *handle, *token, *line;
367 unsigned int token_len, handle_len;
368 unsigned int major, minor, seq_window;
369
370 int pos = 0;
371 struct cache_struct *x;
372
373 /* print it */
374
375 (void) sprintf(get_line(pos, getxdr_pos()), "RPCSEC_GSS_INIT result:");
376
377 pos = getxdr_pos();
378 handle_len = getxdr_u_long();
379 handle = getxdr_hex(handle_len);
380 line = get_line(pos, getxdr_pos());
381 sprintf(line, " handle: length = %d, data = [%s]",
382 handle_len, handle);
383 pos = getxdr_pos();
384 major = getxdr_u_long();
385 minor = getxdr_u_long();
386 seq_window = getxdr_u_long();
387
388 (void) sprintf(get_line(pos, getxdr_pos()),
389 " gss_major status = %u", major);
390
391 (void) sprintf(get_line(pos, getxdr_pos()),
392 " gss_minor status = %u", minor);
393
394 (void) sprintf(get_line(pos, getxdr_pos()),
395 " sequence window = %u", seq_window);
396 pos = getxdr_pos();
397 token_len = getxdr_u_long();
398 token = getxdr_hex(token_len);
399 line = get_line(pos, getxdr_pos());
400 sprintf(line, " gss token: length = %d, data = [%d bytes]",
401 token_len, token_len);
402 show_trailer();
403 }