2 * Copyright (c) 2008 Doug Rabson
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 RPCSEC_GSS client routines.
31 Copyright (c) 2000 The Regents of the University of Michigan.
34 Copyright (c) 2000 Dug Song <dugsong@UMICH.EDU>.
35 All rights reserved, all wrongs reversed.
37 Redistribution and use in source and binary forms, with or without
38 modification, are permitted provided that the following conditions
41 1. Redistributions of source code must retain the above copyright
42 notice, this list of conditions and the following disclaimer.
43 2. Redistributions in binary form must reproduce the above copyright
44 notice, this list of conditions and the following disclaimer in the
45 documentation and/or other materials provided with the distribution.
46 3. Neither the name of the University nor the names of its
47 contributors may be used to endorse or promote products derived
48 from this software without specific prior written permission.
50 THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
51 WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
52 MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
53 DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
54 FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
55 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
56 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
57 BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
58 LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
59 NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
60 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
62 $Id: auth_gss.c,v 1.32 2002/01/15 15:43:00 andros Exp $
65 #include <sys/cdefs.h>
66 __FBSDID("$FreeBSD$");
68 #include <sys/param.h>
69 #include <sys/systm.h>
71 #include <sys/kernel.h>
74 #include <sys/malloc.h>
76 #include <sys/mutex.h>
78 #include <sys/refcount.h>
80 #include <sys/ucred.h>
83 #include <rpc/rpcsec_gss.h>
85 #include <kgssapi/krb5/kcrypto.h>
87 #include "rpcsec_gss_int.h"
89 static void rpc_gss_nextverf(AUTH*);
90 static bool_t rpc_gss_marshal(AUTH *, uint32_t, XDR *, struct mbuf *);
91 static bool_t rpc_gss_init(AUTH *auth, rpc_gss_options_ret_t *options_ret);
92 static bool_t rpc_gss_refresh(AUTH *, void *);
93 static bool_t rpc_gss_validate(AUTH *, uint32_t, struct opaque_auth *,
95 static void rpc_gss_destroy(AUTH *);
96 static void rpc_gss_destroy_context(AUTH *, bool_t);
98 static struct auth_ops rpc_gss_ops = {
106 enum rpcsec_gss_state {
109 RPCSEC_GSS_ESTABLISHED,
110 RPCSEC_GSS_DESTROYING
113 struct rpc_pending_request {
114 uint32_t pr_xid; /* XID of rpc */
115 uint32_t pr_seq; /* matching GSS seq */
116 LIST_ENTRY(rpc_pending_request) pr_link;
118 LIST_HEAD(rpc_pending_request_list, rpc_pending_request);
120 struct rpc_gss_data {
121 volatile u_int gd_refs; /* number of current users */
124 AUTH *gd_auth; /* link back to AUTH */
125 struct ucred *gd_ucred; /* matching local cred */
126 char *gd_principal; /* server principal name */
127 char *gd_clntprincipal; /* client principal name */
128 rpc_gss_options_req_t gd_options; /* GSS context options */
129 enum rpcsec_gss_state gd_state; /* connection state */
130 gss_buffer_desc gd_verf; /* save GSS_S_COMPLETE
131 * NULL RPC verfier to
133 * context negotiation */
134 CLIENT *gd_clnt; /* client handle */
135 gss_OID gd_mech; /* mechanism to use */
136 gss_qop_t gd_qop; /* quality of protection */
137 gss_ctx_id_t gd_ctx; /* context id */
138 struct rpc_gss_cred gd_cred; /* client credentials */
139 uint32_t gd_seq; /* next sequence number */
140 u_int gd_win; /* sequence window */
141 struct rpc_pending_request_list gd_reqs;
142 TAILQ_ENTRY(rpc_gss_data) gd_link;
143 TAILQ_ENTRY(rpc_gss_data) gd_alllink;
145 TAILQ_HEAD(rpc_gss_data_list, rpc_gss_data);
147 #define AUTH_PRIVATE(auth) ((struct rpc_gss_data *)auth->ah_private)
149 static struct timeval AUTH_TIMEOUT = { 25, 0 };
151 #define RPC_GSS_HASH_SIZE 11
152 #define RPC_GSS_MAX 256
153 static struct rpc_gss_data_list rpc_gss_cache[RPC_GSS_HASH_SIZE];
154 static struct rpc_gss_data_list rpc_gss_all;
155 static struct sx rpc_gss_lock;
156 static int rpc_gss_count;
158 static AUTH *rpc_gss_seccreate_int(CLIENT *, struct ucred *, const char *,
159 const char *, gss_OID, rpc_gss_service_t, u_int, rpc_gss_options_req_t *,
160 rpc_gss_options_ret_t *);
163 rpc_gss_hashinit(void *dummy)
167 for (i = 0; i < RPC_GSS_HASH_SIZE; i++)
168 TAILQ_INIT(&rpc_gss_cache[i]);
169 TAILQ_INIT(&rpc_gss_all);
170 sx_init(&rpc_gss_lock, "rpc_gss_lock");
172 SYSINIT(rpc_gss_hashinit, SI_SUB_KMEM, SI_ORDER_ANY, rpc_gss_hashinit, NULL);
175 rpc_gss_hash(const char *principal, gss_OID mech,
176 struct ucred *cred, rpc_gss_service_t service)
180 h = HASHSTEP(HASHINIT, cred->cr_uid);
181 h = hash32_str(principal, h);
182 h = hash32_buf(mech->elements, mech->length, h);
183 h = HASHSTEP(h, (int) service);
185 return (h % RPC_GSS_HASH_SIZE);
189 * Simplified interface to create a security association for the
190 * current thread's * ucred.
193 rpc_gss_secfind(CLIENT *clnt, struct ucred *cred, const char *principal,
194 gss_OID mech_oid, rpc_gss_service_t service)
198 struct rpc_gss_data *gd, *tgd;
199 rpc_gss_options_ret_t options;
201 if (rpc_gss_count > RPC_GSS_MAX) {
202 while (rpc_gss_count > RPC_GSS_MAX) {
203 sx_xlock(&rpc_gss_lock);
204 tgd = TAILQ_FIRST(&rpc_gss_all);
206 TAILQ_REMOVE(&rpc_gss_cache[th], tgd, gd_link);
207 TAILQ_REMOVE(&rpc_gss_all, tgd, gd_alllink);
209 sx_xunlock(&rpc_gss_lock);
210 AUTH_DESTROY(tgd->gd_auth);
215 * See if we already have an AUTH which matches.
217 h = rpc_gss_hash(principal, mech_oid, cred, service);
220 sx_slock(&rpc_gss_lock);
221 TAILQ_FOREACH(gd, &rpc_gss_cache[h], gd_link) {
222 if (gd->gd_ucred->cr_uid == cred->cr_uid
223 && !strcmp(gd->gd_principal, principal)
224 && gd->gd_mech == mech_oid
225 && gd->gd_cred.gc_svc == service) {
226 refcount_acquire(&gd->gd_refs);
227 if (sx_try_upgrade(&rpc_gss_lock)) {
229 * Keep rpc_gss_all LRU sorted.
231 TAILQ_REMOVE(&rpc_gss_all, gd, gd_alllink);
232 TAILQ_INSERT_TAIL(&rpc_gss_all, gd,
234 sx_xunlock(&rpc_gss_lock);
236 sx_sunlock(&rpc_gss_lock);
240 * If the state != ESTABLISHED, try and initialize
241 * the authenticator again. This will happen if the
242 * user's credentials have expired. It may succeed now,
243 * if they have done a kinit or similar.
245 if (gd->gd_state != RPCSEC_GSS_ESTABLISHED) {
246 memset(&options, 0, sizeof (options));
247 (void) rpc_gss_init(gd->gd_auth, &options);
249 return (gd->gd_auth);
252 sx_sunlock(&rpc_gss_lock);
255 * We missed in the cache - create a new association.
257 auth = rpc_gss_seccreate_int(clnt, cred, NULL, principal, mech_oid,
258 service, GSS_C_QOP_DEFAULT, NULL, NULL);
262 gd = AUTH_PRIVATE(auth);
265 sx_xlock(&rpc_gss_lock);
266 TAILQ_FOREACH(tgd, &rpc_gss_cache[h], gd_link) {
267 if (tgd->gd_ucred->cr_uid == cred->cr_uid
268 && !strcmp(tgd->gd_principal, principal)
269 && tgd->gd_mech == mech_oid
270 && tgd->gd_cred.gc_svc == service) {
272 * We lost a race to create the AUTH that
275 sx_xunlock(&rpc_gss_lock);
282 TAILQ_INSERT_TAIL(&rpc_gss_cache[h], gd, gd_link);
283 TAILQ_INSERT_TAIL(&rpc_gss_all, gd, gd_alllink);
284 refcount_acquire(&gd->gd_refs); /* one for the cache, one for user */
285 sx_xunlock(&rpc_gss_lock);
291 rpc_gss_secpurge(CLIENT *clnt)
294 struct rpc_gss_data *gd, *tgd;
296 TAILQ_FOREACH_SAFE(gd, &rpc_gss_all, gd_alllink, tgd) {
297 if (gd->gd_clnt == clnt) {
298 sx_xlock(&rpc_gss_lock);
300 TAILQ_REMOVE(&rpc_gss_cache[h], gd, gd_link);
301 TAILQ_REMOVE(&rpc_gss_all, gd, gd_alllink);
303 sx_xunlock(&rpc_gss_lock);
304 AUTH_DESTROY(gd->gd_auth);
310 rpc_gss_seccreate(CLIENT *clnt, struct ucred *cred, const char *clnt_principal,
311 const char *principal, const char *mechanism, rpc_gss_service_t service,
312 const char *qop, rpc_gss_options_req_t *options_req,
313 rpc_gss_options_ret_t *options_ret)
319 * Bail out now if we don't know this mechanism.
321 if (!rpc_gss_mech_to_oid(mechanism, &oid))
325 if (!rpc_gss_qop_to_num(qop, mechanism, &qop_num))
328 qop_num = GSS_C_QOP_DEFAULT;
331 return (rpc_gss_seccreate_int(clnt, cred, clnt_principal, principal,
332 oid, service, qop_num, options_req, options_ret));
336 rpc_gss_refresh_auth(AUTH *auth)
338 struct rpc_gss_data *gd;
339 rpc_gss_options_ret_t options;
341 gd = AUTH_PRIVATE(auth);
343 * If the state != ESTABLISHED, try and initialize
344 * the authenticator again. This will happen if the
345 * user's credentials have expired. It may succeed now,
346 * if they have done a kinit or similar.
348 if (gd->gd_state != RPCSEC_GSS_ESTABLISHED) {
349 memset(&options, 0, sizeof (options));
350 (void) rpc_gss_init(auth, &options);
355 rpc_gss_seccreate_int(CLIENT *clnt, struct ucred *cred,
356 const char *clnt_principal, const char *principal, gss_OID mech_oid,
357 rpc_gss_service_t service, u_int qop_num,
358 rpc_gss_options_req_t *options_req, rpc_gss_options_ret_t *options_ret)
361 rpc_gss_options_ret_t options;
362 struct rpc_gss_data *gd;
365 * If the caller doesn't want the options, point at local
366 * storage to simplify the code below.
369 options_ret = &options;
372 * Default service is integrity.
374 if (service == rpc_gss_svc_default)
375 service = rpc_gss_svc_integrity;
377 memset(options_ret, 0, sizeof(*options_ret));
379 rpc_gss_log_debug("in rpc_gss_seccreate()");
381 memset(&rpc_createerr, 0, sizeof(rpc_createerr));
383 auth = mem_alloc(sizeof(*auth));
385 rpc_createerr.cf_stat = RPC_SYSTEMERROR;
386 rpc_createerr.cf_error.re_errno = ENOMEM;
389 gd = mem_alloc(sizeof(*gd));
391 rpc_createerr.cf_stat = RPC_SYSTEMERROR;
392 rpc_createerr.cf_error.re_errno = ENOMEM;
393 mem_free(auth, sizeof(*auth));
397 auth->ah_ops = &rpc_gss_ops;
398 auth->ah_private = (caddr_t) gd;
399 auth->ah_cred.oa_flavor = RPCSEC_GSS;
401 refcount_init(&gd->gd_refs, 1);
402 mtx_init(&gd->gd_lock, "gd->gd_lock", NULL, MTX_DEF);
404 gd->gd_ucred = crdup(cred);
405 gd->gd_principal = strdup(principal, M_RPC);
406 if (clnt_principal != NULL)
407 gd->gd_clntprincipal = strdup(clnt_principal, M_RPC);
409 gd->gd_clntprincipal = NULL;
413 gd->gd_options = *options_req;
415 gd->gd_options.req_flags = GSS_C_MUTUAL_FLAG;
416 gd->gd_options.time_req = 0;
417 gd->gd_options.my_cred = GSS_C_NO_CREDENTIAL;
418 gd->gd_options.input_channel_bindings = NULL;
422 gd->gd_ctx = GSS_C_NO_CONTEXT;
423 gd->gd_mech = mech_oid;
424 gd->gd_qop = qop_num;
426 gd->gd_cred.gc_version = RPCSEC_GSS_VERSION;
427 gd->gd_cred.gc_proc = RPCSEC_GSS_INIT;
428 gd->gd_cred.gc_seq = 0;
429 gd->gd_cred.gc_svc = service;
430 LIST_INIT(&gd->gd_reqs);
432 if (!rpc_gss_init(auth, options_ret)) {
444 rpc_gss_set_defaults(AUTH *auth, rpc_gss_service_t service, const char *qop)
446 struct rpc_gss_data *gd;
448 const char *mechanism;
450 gd = AUTH_PRIVATE(auth);
451 if (!rpc_gss_oid_to_mech(gd->gd_mech, &mechanism)) {
456 if (!rpc_gss_qop_to_num(qop, mechanism, &qop_num)) {
460 qop_num = GSS_C_QOP_DEFAULT;
463 gd->gd_cred.gc_svc = service;
464 gd->gd_qop = qop_num;
469 rpc_gss_purge_xid(struct rpc_gss_data *gd, uint32_t xid)
471 struct rpc_pending_request *pr, *npr;
472 struct rpc_pending_request_list reqs;
475 mtx_lock(&gd->gd_lock);
476 LIST_FOREACH_SAFE(pr, &gd->gd_reqs, pr_link, npr) {
477 if (pr->pr_xid == xid) {
478 LIST_REMOVE(pr, pr_link);
479 LIST_INSERT_HEAD(&reqs, pr, pr_link);
483 mtx_unlock(&gd->gd_lock);
485 LIST_FOREACH_SAFE(pr, &reqs, pr_link, npr) {
486 mem_free(pr, sizeof(*pr));
491 rpc_gss_alloc_seq(struct rpc_gss_data *gd)
495 mtx_lock(&gd->gd_lock);
498 mtx_unlock(&gd->gd_lock);
504 rpc_gss_nextverf(__unused AUTH *auth)
511 rpc_gss_marshal(AUTH *auth, uint32_t xid, XDR *xdrs, struct mbuf *args)
513 struct rpc_gss_data *gd;
514 struct rpc_pending_request *pr;
517 struct rpc_gss_cred gsscred;
518 char credbuf[MAX_AUTH_BYTES];
519 struct opaque_auth creds, verf;
520 gss_buffer_desc rpcbuf, checksum;
521 OM_uint32 maj_stat, min_stat;
524 rpc_gss_log_debug("in rpc_gss_marshal()");
526 gd = AUTH_PRIVATE(auth);
528 gsscred = gd->gd_cred;
529 seq = rpc_gss_alloc_seq(gd);
530 gsscred.gc_seq = seq;
532 xdrmem_create(&tmpxdrs, credbuf, sizeof(credbuf), XDR_ENCODE);
533 if (!xdr_rpc_gss_cred(&tmpxdrs, &gsscred)) {
534 XDR_DESTROY(&tmpxdrs);
535 _rpc_gss_set_error(RPC_GSS_ER_SYSTEMERROR, ENOMEM);
538 creds.oa_flavor = RPCSEC_GSS;
539 creds.oa_base = credbuf;
540 creds.oa_length = XDR_GETPOS(&tmpxdrs);
541 XDR_DESTROY(&tmpxdrs);
543 xdr_opaque_auth(xdrs, &creds);
545 if (gd->gd_cred.gc_proc == RPCSEC_GSS_INIT ||
546 gd->gd_cred.gc_proc == RPCSEC_GSS_CONTINUE_INIT) {
547 if (!xdr_opaque_auth(xdrs, &_null_auth)) {
548 _rpc_gss_set_error(RPC_GSS_ER_SYSTEMERROR, ENOMEM);
551 xdrmbuf_append(xdrs, args);
555 * Keep track of this XID + seq pair so that we can do
556 * the matching gss_verify_mic in AUTH_VALIDATE.
558 pr = mem_alloc(sizeof(struct rpc_pending_request));
559 mtx_lock(&gd->gd_lock);
562 LIST_INSERT_HEAD(&gd->gd_reqs, pr, pr_link);
563 mtx_unlock(&gd->gd_lock);
566 * Checksum serialized RPC header, up to and including
567 * credential. For the in-kernel environment, we
568 * assume that our XDR stream is on a contiguous
569 * memory buffer (e.g. an mbuf).
571 rpcbuf.length = XDR_GETPOS(xdrs);
573 rpcbuf.value = XDR_INLINE(xdrs, rpcbuf.length);
575 maj_stat = gss_get_mic(&min_stat, gd->gd_ctx, gd->gd_qop,
578 if (maj_stat != GSS_S_COMPLETE) {
579 rpc_gss_log_status("gss_get_mic", gd->gd_mech,
581 if (maj_stat == GSS_S_CONTEXT_EXPIRED) {
582 rpc_gss_destroy_context(auth, TRUE);
584 _rpc_gss_set_error(RPC_GSS_ER_SYSTEMERROR, EPERM);
588 verf.oa_flavor = RPCSEC_GSS;
589 verf.oa_base = checksum.value;
590 verf.oa_length = checksum.length;
592 xdr_stat = xdr_opaque_auth(xdrs, &verf);
593 gss_release_buffer(&min_stat, &checksum);
595 _rpc_gss_set_error(RPC_GSS_ER_SYSTEMERROR, ENOMEM);
598 if (gd->gd_state != RPCSEC_GSS_ESTABLISHED ||
599 gd->gd_cred.gc_svc == rpc_gss_svc_none) {
600 xdrmbuf_append(xdrs, args);
603 if (!xdr_rpc_gss_wrap_data(&args,
604 gd->gd_ctx, gd->gd_qop, gd->gd_cred.gc_svc,
607 xdrmbuf_append(xdrs, args);
616 rpc_gss_validate(AUTH *auth, uint32_t xid, struct opaque_auth *verf,
617 struct mbuf **resultsp)
619 struct rpc_gss_data *gd;
620 struct rpc_pending_request *pr, *npr;
621 struct rpc_pending_request_list reqs;
624 gss_buffer_desc signbuf, checksum;
625 OM_uint32 maj_stat, min_stat;
627 rpc_gss_log_debug("in rpc_gss_validate()");
629 gd = AUTH_PRIVATE(auth);
632 * The client will call us with a NULL verf when it gives up
636 rpc_gss_purge_xid(gd, xid);
640 if (gd->gd_state == RPCSEC_GSS_CONTEXT) {
642 * Save the on the wire verifier to validate last INIT
643 * phase packet after decode if the major status is
646 if (gd->gd_verf.value)
647 xdr_free((xdrproc_t) xdr_gss_buffer_desc,
648 (char *) &gd->gd_verf);
649 gd->gd_verf.value = mem_alloc(verf->oa_length);
650 if (gd->gd_verf.value == NULL) {
651 printf("gss_validate: out of memory\n");
652 _rpc_gss_set_error(RPC_GSS_ER_SYSTEMERROR, ENOMEM);
657 memcpy(gd->gd_verf.value, verf->oa_base, verf->oa_length);
658 gd->gd_verf.length = verf->oa_length;
664 * We need to check the verifier against all the requests
665 * we've send for this XID - for unreliable protocols, we
666 * retransmit with the same XID but different sequence
667 * number. We temporarily take this set of requests out of the
668 * list so that we can work through the list without having to
671 mtx_lock(&gd->gd_lock);
673 LIST_FOREACH_SAFE(pr, &gd->gd_reqs, pr_link, npr) {
674 if (pr->pr_xid == xid) {
675 LIST_REMOVE(pr, pr_link);
676 LIST_INSERT_HEAD(&reqs, pr, pr_link);
679 mtx_unlock(&gd->gd_lock);
680 LIST_FOREACH(pr, &reqs, pr_link) {
681 if (pr->pr_xid == xid) {
684 signbuf.value = #
685 signbuf.length = sizeof(num);
687 checksum.value = verf->oa_base;
688 checksum.length = verf->oa_length;
690 maj_stat = gss_verify_mic(&min_stat, gd->gd_ctx,
691 &signbuf, &checksum, &qop_state);
692 if (maj_stat != GSS_S_COMPLETE
693 || qop_state != gd->gd_qop) {
696 if (maj_stat == GSS_S_CONTEXT_EXPIRED) {
697 rpc_gss_destroy_context(auth, TRUE);
700 //rpc_gss_purge_reqs(gd, seq);
701 LIST_FOREACH_SAFE(pr, &reqs, pr_link, npr)
702 mem_free(pr, sizeof(*pr));
704 if (gd->gd_cred.gc_svc == rpc_gss_svc_none) {
707 if (!xdr_rpc_gss_unwrap_data(resultsp,
708 gd->gd_ctx, gd->gd_qop,
709 gd->gd_cred.gc_svc, seq)) {
718 * We didn't match - put back any entries for this XID so that
719 * a future call to validate can retry.
721 mtx_lock(&gd->gd_lock);
722 LIST_FOREACH_SAFE(pr, &reqs, pr_link, npr) {
723 LIST_REMOVE(pr, pr_link);
724 LIST_INSERT_HEAD(&gd->gd_reqs, pr, pr_link);
726 mtx_unlock(&gd->gd_lock);
729 * Nothing matches - give up.
731 _rpc_gss_set_error(RPC_GSS_ER_SYSTEMERROR, EPERM);
738 rpc_gss_init(AUTH *auth, rpc_gss_options_ret_t *options_ret)
740 struct thread *td = curthread;
741 struct ucred *crsave;
742 struct rpc_gss_data *gd;
743 struct rpc_gss_init_res gr;
744 gss_buffer_desc principal_desc;
745 gss_buffer_desc *recv_tokenp, recv_token, send_token;
747 OM_uint32 maj_stat, min_stat, call_stat;
749 struct rpc_callextra ext;
751 gss_OID_set mechlist;
753 rpc_gss_log_debug("in rpc_gss_refresh()");
755 gd = AUTH_PRIVATE(auth);
757 mtx_lock(&gd->gd_lock);
759 * If the context isn't in START state, someone else is
760 * refreshing - we wait till they are done. If they fail, they
761 * will put the state back to START and we can try (most
762 * likely to also fail).
764 while (gd->gd_state != RPCSEC_GSS_START
765 && gd->gd_state != RPCSEC_GSS_ESTABLISHED) {
766 msleep(gd, &gd->gd_lock, 0, "gssstate", 0);
768 if (gd->gd_state == RPCSEC_GSS_ESTABLISHED) {
769 mtx_unlock(&gd->gd_lock);
772 gd->gd_state = RPCSEC_GSS_CONTEXT;
773 mtx_unlock(&gd->gd_lock);
775 gd->gd_cred.gc_proc = RPCSEC_GSS_INIT;
776 gd->gd_cred.gc_seq = 0;
779 * For KerberosV, if there is a client principal name, that implies
780 * that this is a host based initiator credential in the default
781 * keytab file. For this case, it is necessary to do a
782 * gss_acquire_cred(). When this is done, the gssd daemon will
783 * do the equivalent of "kinit -k" to put a TGT for the name in
784 * the credential cache file for the gssd daemon.
786 if (gd->gd_clntprincipal != NULL &&
787 rpc_gss_mech_to_oid("kerberosv5", &mech_oid) &&
788 gd->gd_mech == mech_oid) {
789 /* Get rid of any old credential. */
790 if (gd->gd_options.my_cred != GSS_C_NO_CREDENTIAL) {
791 gss_release_cred(&min_stat, &gd->gd_options.my_cred);
792 gd->gd_options.my_cred = GSS_C_NO_CREDENTIAL;
796 * The mechanism must be set to KerberosV for acquisition
797 * of credentials to work reliably.
799 maj_stat = gss_create_empty_oid_set(&min_stat, &mechlist);
800 if (maj_stat != GSS_S_COMPLETE) {
801 options_ret->major_status = maj_stat;
802 options_ret->minor_status = min_stat;
805 maj_stat = gss_add_oid_set_member(&min_stat, gd->gd_mech,
807 if (maj_stat != GSS_S_COMPLETE) {
808 options_ret->major_status = maj_stat;
809 options_ret->minor_status = min_stat;
810 gss_release_oid_set(&min_stat, &mechlist);
814 principal_desc.value = (void *)gd->gd_clntprincipal;
815 principal_desc.length = strlen(gd->gd_clntprincipal);
816 maj_stat = gss_import_name(&min_stat, &principal_desc,
817 GSS_C_NT_HOSTBASED_SERVICE, &name);
818 if (maj_stat != GSS_S_COMPLETE) {
819 options_ret->major_status = maj_stat;
820 options_ret->minor_status = min_stat;
821 gss_release_oid_set(&min_stat, &mechlist);
824 /* Acquire the credentials. */
825 maj_stat = gss_acquire_cred(&min_stat, name, 0,
826 mechlist, GSS_C_INITIATE,
827 &gd->gd_options.my_cred, NULL, NULL);
828 gss_release_name(&min_stat, &name);
829 gss_release_oid_set(&min_stat, &mechlist);
830 if (maj_stat != GSS_S_COMPLETE) {
831 options_ret->major_status = maj_stat;
832 options_ret->minor_status = min_stat;
837 principal_desc.value = (void *)gd->gd_principal;
838 principal_desc.length = strlen(gd->gd_principal);
839 maj_stat = gss_import_name(&min_stat, &principal_desc,
840 GSS_C_NT_HOSTBASED_SERVICE, &name);
841 if (maj_stat != GSS_S_COMPLETE) {
842 options_ret->major_status = maj_stat;
843 options_ret->minor_status = min_stat;
847 /* GSS context establishment loop. */
848 memset(&recv_token, 0, sizeof(recv_token));
849 memset(&gr, 0, sizeof(gr));
850 memset(options_ret, 0, sizeof(*options_ret));
851 options_ret->major_status = GSS_S_FAILURE;
852 recv_tokenp = GSS_C_NO_BUFFER;
855 crsave = td->td_ucred;
856 td->td_ucred = gd->gd_ucred;
857 maj_stat = gss_init_sec_context(&min_stat,
858 gd->gd_options.my_cred,
862 gd->gd_options.req_flags,
863 gd->gd_options.time_req,
864 gd->gd_options.input_channel_bindings,
866 &gd->gd_mech, /* used mech */
868 &options_ret->ret_flags,
869 &options_ret->time_req);
870 td->td_ucred = crsave;
873 * Free the token which we got from the server (if
874 * any). Remember that this was allocated by XDR, not
877 if (recv_tokenp != GSS_C_NO_BUFFER) {
878 xdr_free((xdrproc_t) xdr_gss_buffer_desc,
879 (char *) &recv_token);
880 recv_tokenp = GSS_C_NO_BUFFER;
882 if (gd->gd_mech && rpc_gss_oid_to_mech(gd->gd_mech, &mech)) {
883 strlcpy(options_ret->actual_mechanism,
885 sizeof(options_ret->actual_mechanism));
887 if (maj_stat != GSS_S_COMPLETE &&
888 maj_stat != GSS_S_CONTINUE_NEEDED) {
889 rpc_gss_log_status("gss_init_sec_context", gd->gd_mech,
891 options_ret->major_status = maj_stat;
892 options_ret->minor_status = min_stat;
895 if (send_token.length != 0) {
896 memset(&gr, 0, sizeof(gr));
898 bzero(&ext, sizeof(ext));
900 call_stat = CLNT_CALL_EXT(gd->gd_clnt, &ext, NULLPROC,
901 (xdrproc_t)xdr_gss_buffer_desc,
903 (xdrproc_t)xdr_rpc_gss_init_res,
904 (caddr_t)&gr, AUTH_TIMEOUT);
906 gss_release_buffer(&min_stat, &send_token);
908 if (call_stat != RPC_SUCCESS)
911 if (gr.gr_major != GSS_S_COMPLETE &&
912 gr.gr_major != GSS_S_CONTINUE_NEEDED) {
913 rpc_gss_log_status("server reply", gd->gd_mech,
914 gr.gr_major, gr.gr_minor);
915 options_ret->major_status = gr.gr_major;
916 options_ret->minor_status = gr.gr_minor;
921 * Save the server's gr_handle value, freeing
922 * what we have already (remember that this
923 * was allocated by XDR, not GSS-API).
925 if (gr.gr_handle.length != 0) {
926 xdr_free((xdrproc_t) xdr_gss_buffer_desc,
927 (char *) &gd->gd_cred.gc_handle);
928 gd->gd_cred.gc_handle = gr.gr_handle;
932 * Save the server's token as well.
934 if (gr.gr_token.length != 0) {
935 recv_token = gr.gr_token;
936 recv_tokenp = &recv_token;
940 * Since we have copied out all the bits of gr
941 * which XDR allocated for us, we don't need
944 gd->gd_cred.gc_proc = RPCSEC_GSS_CONTINUE_INIT;
947 if (maj_stat == GSS_S_COMPLETE) {
948 gss_buffer_desc bufin;
949 u_int seq, qop_state = 0;
952 * gss header verifier,
953 * usually checked in gss_validate
955 seq = htonl(gr.gr_win);
956 bufin.value = (unsigned char *)&seq;
957 bufin.length = sizeof(seq);
959 maj_stat = gss_verify_mic(&min_stat, gd->gd_ctx,
960 &bufin, &gd->gd_verf, &qop_state);
962 if (maj_stat != GSS_S_COMPLETE ||
963 qop_state != gd->gd_qop) {
964 rpc_gss_log_status("gss_verify_mic", gd->gd_mech,
966 if (maj_stat == GSS_S_CONTEXT_EXPIRED) {
967 rpc_gss_destroy_context(auth, TRUE);
969 _rpc_gss_set_error(RPC_GSS_ER_SYSTEMERROR,
971 options_ret->major_status = maj_stat;
972 options_ret->minor_status = min_stat;
976 options_ret->major_status = GSS_S_COMPLETE;
977 options_ret->minor_status = 0;
978 options_ret->rpcsec_version = gd->gd_cred.gc_version;
979 options_ret->gss_context = gd->gd_ctx;
981 gd->gd_cred.gc_proc = RPCSEC_GSS_DATA;
983 gd->gd_win = gr.gr_win;
988 gss_release_name(&min_stat, &name);
989 xdr_free((xdrproc_t) xdr_gss_buffer_desc,
990 (char *) &gd->gd_verf);
993 /* End context negotiation loop. */
994 if (gd->gd_cred.gc_proc != RPCSEC_GSS_DATA) {
995 rpc_createerr.cf_stat = RPC_AUTHERROR;
996 _rpc_gss_set_error(RPC_GSS_ER_SYSTEMERROR, EPERM);
998 gss_delete_sec_context(&min_stat, &gd->gd_ctx,
1001 mtx_lock(&gd->gd_lock);
1002 gd->gd_state = RPCSEC_GSS_START;
1004 mtx_unlock(&gd->gd_lock);
1008 mtx_lock(&gd->gd_lock);
1009 gd->gd_state = RPCSEC_GSS_ESTABLISHED;
1011 mtx_unlock(&gd->gd_lock);
1017 rpc_gss_refresh(AUTH *auth, void *msg)
1019 struct rpc_msg *reply = (struct rpc_msg *) msg;
1020 rpc_gss_options_ret_t options;
1021 struct rpc_gss_data *gd;
1023 gd = AUTH_PRIVATE(auth);
1026 * If the context is in DESTROYING state, then just return, since
1027 * there is no point in refreshing the credentials.
1029 mtx_lock(&gd->gd_lock);
1030 if (gd->gd_state == RPCSEC_GSS_DESTROYING) {
1031 mtx_unlock(&gd->gd_lock);
1034 mtx_unlock(&gd->gd_lock);
1037 * If the error was RPCSEC_GSS_CREDPROBLEM of
1038 * RPCSEC_GSS_CTXPROBLEM we start again from scratch. All
1039 * other errors are fatal.
1041 if (reply->rm_reply.rp_stat == MSG_DENIED
1042 && reply->rm_reply.rp_rjct.rj_stat == AUTH_ERROR
1043 && (reply->rm_reply.rp_rjct.rj_why == RPCSEC_GSS_CREDPROBLEM
1044 || reply->rm_reply.rp_rjct.rj_why == RPCSEC_GSS_CTXPROBLEM)) {
1045 rpc_gss_destroy_context(auth, FALSE);
1046 memset(&options, 0, sizeof(options));
1047 return (rpc_gss_init(auth, &options));
1054 rpc_gss_destroy_context(AUTH *auth, bool_t send_destroy)
1056 struct rpc_gss_data *gd;
1057 struct rpc_pending_request *pr;
1059 struct rpc_callextra ext;
1061 rpc_gss_log_debug("in rpc_gss_destroy_context()");
1063 gd = AUTH_PRIVATE(auth);
1065 mtx_lock(&gd->gd_lock);
1067 * If the context isn't in ESTABISHED state, someone else is
1068 * destroying/refreshing - we wait till they are done.
1070 if (gd->gd_state != RPCSEC_GSS_ESTABLISHED) {
1071 while (gd->gd_state != RPCSEC_GSS_START
1072 && gd->gd_state != RPCSEC_GSS_ESTABLISHED)
1073 msleep(gd, &gd->gd_lock, 0, "gssstate", 0);
1074 mtx_unlock(&gd->gd_lock);
1077 gd->gd_state = RPCSEC_GSS_DESTROYING;
1078 mtx_unlock(&gd->gd_lock);
1081 gd->gd_cred.gc_proc = RPCSEC_GSS_DESTROY;
1082 bzero(&ext, sizeof(ext));
1084 CLNT_CALL_EXT(gd->gd_clnt, &ext, NULLPROC,
1085 (xdrproc_t)xdr_void, NULL,
1086 (xdrproc_t)xdr_void, NULL, AUTH_TIMEOUT);
1089 while ((pr = LIST_FIRST(&gd->gd_reqs)) != NULL) {
1090 LIST_REMOVE(pr, pr_link);
1091 mem_free(pr, sizeof(*pr));
1095 * Free the context token. Remember that this was
1096 * allocated by XDR, not GSS-API.
1098 xdr_free((xdrproc_t) xdr_gss_buffer_desc,
1099 (char *) &gd->gd_cred.gc_handle);
1100 gd->gd_cred.gc_handle.length = 0;
1102 if (gd->gd_ctx != GSS_C_NO_CONTEXT)
1103 gss_delete_sec_context(&min_stat, &gd->gd_ctx, NULL);
1105 mtx_lock(&gd->gd_lock);
1106 gd->gd_state = RPCSEC_GSS_START;
1108 mtx_unlock(&gd->gd_lock);
1112 rpc_gss_destroy(AUTH *auth)
1114 struct rpc_gss_data *gd;
1116 rpc_gss_log_debug("in rpc_gss_destroy()");
1118 gd = AUTH_PRIVATE(auth);
1120 if (!refcount_release(&gd->gd_refs))
1123 rpc_gss_destroy_context(auth, TRUE);
1125 CLNT_RELEASE(gd->gd_clnt);
1126 crfree(gd->gd_ucred);
1127 free(gd->gd_principal, M_RPC);
1128 if (gd->gd_clntprincipal != NULL)
1129 free(gd->gd_clntprincipal, M_RPC);
1130 if (gd->gd_verf.value)
1131 xdr_free((xdrproc_t) xdr_gss_buffer_desc,
1132 (char *) &gd->gd_verf);
1133 mtx_destroy(&gd->gd_lock);
1135 mem_free(gd, sizeof(*gd));
1136 mem_free(auth, sizeof(*auth));
1140 rpc_gss_max_data_length(AUTH *auth, int max_tp_unit_len)
1142 struct rpc_gss_data *gd;
1145 OM_uint32 maj_stat, min_stat;
1148 gd = AUTH_PRIVATE(auth);
1150 switch (gd->gd_cred.gc_svc) {
1151 case rpc_gss_svc_none:
1152 return (max_tp_unit_len);
1155 case rpc_gss_svc_default:
1156 case rpc_gss_svc_integrity:
1160 case rpc_gss_svc_privacy:
1168 maj_stat = gss_wrap_size_limit(&min_stat, gd->gd_ctx, want_conf,
1169 gd->gd_qop, max_tp_unit_len, &max);
1171 if (maj_stat == GSS_S_COMPLETE) {
1177 rpc_gss_log_status("gss_wrap_size_limit", gd->gd_mech,
1178 maj_stat, min_stat);