xref: /freebsd/sys/rpc/rpcsec_gss/rpcsec_gss_prot.c (revision 195ebc7e9e4b129de810833791a19dfb4349d6a9) 
1 /*
2   rpcsec_gss_prot.c
3 
4   Copyright (c) 2000 The Regents of the University of Michigan.
5   All rights reserved.
6 
7   Copyright (c) 2000 Dug Song <dugsong@UMICH.EDU>.
8   All rights reserved, all wrongs reversed.
9 
10   Redistribution and use in source and binary forms, with or without
11   modification, are permitted provided that the following conditions
12   are met:
13 
14   1. Redistributions of source code must retain the above copyright
15      notice, this list of conditions and the following disclaimer.
16   2. Redistributions in binary form must reproduce the above copyright
17      notice, this list of conditions and the following disclaimer in the
18      documentation and/or other materials provided with the distribution.
19   3. Neither the name of the University nor the names of its
20      contributors may be used to endorse or promote products derived
21      from this software without specific prior written permission.
22 
23   THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
24   WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
25   MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
26   DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
27   FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
28   CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
29   SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
30   BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
31   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
32   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
33   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
34 
35   $Id: authgss_prot.c,v 1.18 2000/09/01 04:14:03 dugsong Exp $
36 */
37 
38 #include <sys/cdefs.h>
39 __FBSDID("$FreeBSD$");
40 
41 #include <sys/param.h>
42 #include <sys/systm.h>
43 #include <sys/kobj.h>
44 #include <sys/lock.h>
45 #include <sys/malloc.h>
46 #include <sys/mbuf.h>
47 #include <sys/mutex.h>
48 
49 #include <rpc/rpc.h>
50 #include <rpc/rpcsec_gss.h>
51 
52 #include "rpcsec_gss_int.h"
53 
54 #define MAX_GSS_SIZE	10240	/* XXX */
55 
56 #if 0				/* use the one from kgssapi */
57 bool_t
58 xdr_gss_buffer_desc(XDR *xdrs, gss_buffer_desc *p)
59 {
60 	char *val;
61 	u_int len;
62 	bool_t ret;
63 
64 	val = p->value;
65 	len = p->length;
66 	ret = xdr_bytes(xdrs, &val, &len, MAX_GSS_SIZE);
67 	p->value = val;
68 	p->length = len;
69 
70 	return (ret);
71 }
72 #endif
73 
74 bool_t
75 xdr_rpc_gss_cred(XDR *xdrs, struct rpc_gss_cred *p)
76 {
77 	enum_t proc, svc;
78 	bool_t ret;
79 
80 	proc = p->gc_proc;
81 	svc = p->gc_svc;
82 	ret = (xdr_u_int(xdrs, &p->gc_version) &&
83 	    xdr_enum(xdrs, &proc) &&
84 	    xdr_u_int(xdrs, &p->gc_seq) &&
85 	    xdr_enum(xdrs, &svc) &&
86 	    xdr_gss_buffer_desc(xdrs, &p->gc_handle));
87 	p->gc_proc = proc;
88 	p->gc_svc = svc;
89 
90 	return (ret);
91 }
92 
93 bool_t
94 xdr_rpc_gss_init_res(XDR *xdrs, struct rpc_gss_init_res *p)
95 {
96 
97 	return (xdr_gss_buffer_desc(xdrs, &p->gr_handle) &&
98 	    xdr_u_int(xdrs, &p->gr_major) &&
99 	    xdr_u_int(xdrs, &p->gr_minor) &&
100 	    xdr_u_int(xdrs, &p->gr_win) &&
101 	    xdr_gss_buffer_desc(xdrs, &p->gr_token));
102 }
103 
104 static void
105 put_uint32(struct mbuf **mp, uint32_t v)
106 {
107 	struct mbuf *m = *mp;
108 	uint32_t n;
109 
110 	M_PREPEND(m, sizeof(uint32_t), M_WAIT);
111 	n = htonl(v);
112 	bcopy(&n, mtod(m, uint32_t *), sizeof(uint32_t));
113 	*mp = m;
114 }
115 
116 bool_t
117 xdr_rpc_gss_wrap_data(struct mbuf **argsp,
118 		      gss_ctx_id_t ctx, gss_qop_t qop,
119 		      rpc_gss_service_t svc, u_int seq)
120 {
121 	struct mbuf	*args, *mic;
122 	OM_uint32	maj_stat, min_stat;
123 	int		conf_state;
124 	u_int		len;
125 	static char	zpad[4];
126 
127 	args = *argsp;
128 
129 	/*
130 	 * Prepend the sequence number before calling gss_get_mic or gss_wrap.
131 	 */
132 	put_uint32(&args, seq);
133 	len = m_length(args, NULL);
134 
135 	if (svc == rpc_gss_svc_integrity) {
136 		/* Checksum rpc_gss_data_t. */
137 		maj_stat = gss_get_mic_mbuf(&min_stat, ctx, qop, args, &mic);
138 		if (maj_stat != GSS_S_COMPLETE) {
139 			rpc_gss_log_debug("gss_get_mic failed");
140 			m_freem(args);
141 			return (FALSE);
142 		}
143 
144 		/*
145 		 * Marshal databody_integ. Note that since args is
146 		 * already RPC encoded, there will be no padding.
147 		 */
148 		put_uint32(&args, len);
149 
150 		/*
151 		 * Marshal checksum. This is likely to need padding.
152 		 */
153 		len = m_length(mic, NULL);
154 		put_uint32(&mic, len);
155 		if (len != RNDUP(len)) {
156 			m_append(mic, RNDUP(len) - len, zpad);
157 		}
158 
159 		/*
160 		 * Concatenate databody_integ with checksum.
161 		 */
162 		m_cat(args, mic);
163 	} else if (svc == rpc_gss_svc_privacy) {
164 		/* Encrypt rpc_gss_data_t. */
165 		maj_stat = gss_wrap_mbuf(&min_stat, ctx, TRUE, qop,
166 		    &args, &conf_state);
167 		if (maj_stat != GSS_S_COMPLETE) {
168 			rpc_gss_log_status("gss_wrap", NULL,
169 			    maj_stat, min_stat);
170 			return (FALSE);
171 		}
172 
173 		/*
174 		 *  Marshal databody_priv and deal with RPC padding.
175 		 */
176 		len = m_length(args, NULL);
177 		put_uint32(&args, len);
178 		if (len != RNDUP(len)) {
179 			m_append(args, RNDUP(len) - len, zpad);
180 		}
181 	}
182 	*argsp = args;
183 	return (TRUE);
184 }
185 
186 static uint32_t
187 get_uint32(struct mbuf **mp)
188 {
189 	struct mbuf *m = *mp;
190 	uint32_t n;
191 
192 	if (m->m_len < sizeof(uint32_t)) {
193 		m = m_pullup(m, sizeof(uint32_t));
194 		if (!m) {
195 			*mp = NULL;
196 			return (0);
197 		}
198 	}
199 	bcopy(mtod(m, uint32_t *), &n, sizeof(uint32_t));
200 	m_adj(m, sizeof(uint32_t));
201 	*mp = m;
202 	return (ntohl(n));
203 }
204 
205 static void
206 m_trim(struct mbuf *m, int len)
207 {
208 	struct mbuf *n;
209 	int off;
210 
211 	n = m_getptr(m, len, &off);
212 	if (n) {
213 		n->m_len = off;
214 		if (n->m_next) {
215 			m_freem(n->m_next);
216 			n->m_next = NULL;
217 		}
218 	}
219 }
220 
221 bool_t
222 xdr_rpc_gss_unwrap_data(struct mbuf **resultsp,
223 			gss_ctx_id_t ctx, gss_qop_t qop,
224 			rpc_gss_service_t svc, u_int seq)
225 {
226 	struct mbuf	*results, *message, *mic;
227 	uint32_t	len, cklen;
228 	OM_uint32	maj_stat, min_stat;
229 	u_int		seq_num, conf_state, qop_state;
230 
231 	results = *resultsp;
232 	*resultsp = NULL;
233 
234 	message = NULL;
235 	if (svc == rpc_gss_svc_integrity) {
236 		/*
237 		 * Extract the seq+message part. Remember that there
238 		 * may be extra RPC padding in the checksum. The
239 		 * message part is RPC encoded already so no
240 		 * padding.
241 		 */
242 		len = get_uint32(&results);
243 		message = results;
244 		results = m_split(results, len, M_WAIT);
245 		if (!results) {
246 			m_freem(message);
247 			return (FALSE);
248 		}
249 
250 		/*
251 		 * Extract the MIC and make it contiguous.
252 		 */
253 		cklen = get_uint32(&results);
254 		KASSERT(cklen <= MHLEN, ("unexpected large GSS-API checksum"));
255 		mic = results;
256 		if (cklen > mic->m_len)
257 			mic = m_pullup(mic, cklen);
258 		if (cklen != RNDUP(cklen))
259 			m_trim(mic, cklen);
260 
261 		/* Verify checksum and QOP. */
262 		maj_stat = gss_verify_mic_mbuf(&min_stat, ctx,
263 		    message, mic, &qop_state);
264 		m_freem(mic);
265 
266 		if (maj_stat != GSS_S_COMPLETE || qop_state != qop) {
267 			m_freem(message);
268 			rpc_gss_log_status("gss_verify_mic", NULL,
269 			    maj_stat, min_stat);
270 			return (FALSE);
271 		}
272 	} else if (svc == rpc_gss_svc_privacy) {
273 		/* Decode databody_priv. */
274 		len = get_uint32(&results);
275 
276 		/* Decrypt databody. */
277 		message = results;
278 		if (len != RNDUP(len))
279 			m_trim(message, len);
280 		maj_stat = gss_unwrap_mbuf(&min_stat, ctx, &message,
281 		    &conf_state, &qop_state);
282 
283 		/* Verify encryption and QOP. */
284 		if (maj_stat != GSS_S_COMPLETE) {
285 			rpc_gss_log_status("gss_unwrap", NULL,
286 			    maj_stat, min_stat);
287 			return (FALSE);
288 		}
289 		if (qop_state != qop || conf_state != TRUE) {
290 			m_freem(results);
291 			return (FALSE);
292 		}
293 	}
294 
295 	/* Decode rpc_gss_data_t (sequence number + arguments). */
296 	seq_num = get_uint32(&message);
297 
298 	/* Verify sequence number. */
299 	if (seq_num != seq) {
300 		rpc_gss_log_debug("wrong sequence number in databody");
301 		m_freem(message);
302 		return (FALSE);
303 	}
304 
305 	*resultsp = message;
306 	return (TRUE);
307 }
308 
309 #ifdef DEBUG
310 #include <ctype.h>
311 
312 void
313 rpc_gss_log_debug(const char *fmt, ...)
314 {
315 	va_list ap;
316 
317 	va_start(ap, fmt);
318 	fprintf(stderr, "rpcsec_gss: ");
319 	vfprintf(stderr, fmt, ap);
320 	fprintf(stderr, "\n");
321 	va_end(ap);
322 }
323 
324 void
325 rpc_gss_log_status(const char *m, gss_OID mech, OM_uint32 maj_stat, OM_uint32 min_stat)
326 {
327 	OM_uint32 min;
328 	gss_buffer_desc msg;
329 	int msg_ctx = 0;
330 
331 	fprintf(stderr, "rpcsec_gss: %s: ", m);
332 
333 	gss_display_status(&min, maj_stat, GSS_C_GSS_CODE, GSS_C_NULL_OID,
334 			   &msg_ctx, &msg);
335 	printf("%s - ", (char *)msg.value);
336 	gss_release_buffer(&min, &msg);
337 
338 	gss_display_status(&min, min_stat, GSS_C_MECH_CODE, mech,
339 			   &msg_ctx, &msg);
340 	printf("%s\n", (char *)msg.value);
341 	gss_release_buffer(&min, &msg);
342 }
343 
344 #else
345 
346 void
347 rpc_gss_log_debug(__unused const char *fmt, ...)
348 {
349 }
350 
351 void
352 rpc_gss_log_status(__unused const char *m, __unused gss_OID mech,
353     __unused OM_uint32 maj_stat, __unused OM_uint32 min_stat)
354 {
355 }
356 
357 #endif
358 
359 
360