auth_gss.c revision 9f06c719f474be7003763284a990bed6377bb0d4
1/* 2 * linux/net/sunrpc/auth_gss/auth_gss.c 3 * 4 * RPCSEC_GSS client authentication. 5 * 6 * Copyright (c) 2000 The Regents of the University of Michigan. 7 * All rights reserved. 8 * 9 * Dug Song <dugsong@monkey.org> 10 * Andy Adamson <andros@umich.edu> 11 * 12 * Redistribution and use in source and binary forms, with or without 13 * modification, are permitted provided that the following conditions 14 * are met: 15 * 16 * 1. Redistributions of source code must retain the above copyright 17 * notice, this list of conditions and the following disclaimer. 18 * 2. Redistributions in binary form must reproduce the above copyright 19 * notice, this list of conditions and the following disclaimer in the 20 * documentation and/or other materials provided with the distribution. 21 * 3. Neither the name of the University nor the names of its 22 * contributors may be used to endorse or promote products derived 23 * from this software without specific prior written permission. 24 * 25 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED 26 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 27 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 28 * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 29 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 30 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 31 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR 32 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 33 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 34 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 35 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 36 */ 37 38 39#include <linux/module.h> 40#include <linux/init.h> 41#include <linux/types.h> 42#include <linux/slab.h> 43#include <linux/sched.h> 44#include <linux/pagemap.h> 45#include <linux/sunrpc/clnt.h> 46#include <linux/sunrpc/auth.h> 47#include <linux/sunrpc/auth_gss.h> 48#include <linux/sunrpc/svcauth_gss.h> 49#include <linux/sunrpc/gss_err.h> 50#include <linux/workqueue.h> 51#include <linux/sunrpc/rpc_pipe_fs.h> 52#include <linux/sunrpc/gss_api.h> 53#include <asm/uaccess.h> 54 55static const struct rpc_authops authgss_ops; 56 57static const struct rpc_credops gss_credops; 58static const struct rpc_credops gss_nullops; 59 60#define GSS_RETRY_EXPIRED 5 61static unsigned int gss_expired_cred_retry_delay = GSS_RETRY_EXPIRED; 62 63#ifdef RPC_DEBUG 64# define RPCDBG_FACILITY RPCDBG_AUTH 65#endif 66 67#define GSS_CRED_SLACK (RPC_MAX_AUTH_SIZE * 2) 68/* length of a krb5 verifier (48), plus data added before arguments when 69 * using integrity (two 4-byte integers): */ 70#define GSS_VERF_SLACK 100 71 72struct gss_auth { 73 struct kref kref; 74 struct rpc_auth rpc_auth; 75 struct gss_api_mech *mech; 76 enum rpc_gss_svc service; 77 struct rpc_clnt *client; 78 /* 79 * There are two upcall pipes; dentry[1], named "gssd", is used 80 * for the new text-based upcall; dentry[0] is named after the 81 * mechanism (for example, "krb5") and exists for 82 * backwards-compatibility with older gssd's. 83 */ 84 struct dentry *dentry[2]; 85}; 86 87/* pipe_version >= 0 if and only if someone has a pipe open. */ 88static int pipe_version = -1; 89static atomic_t pipe_users = ATOMIC_INIT(0); 90static DEFINE_SPINLOCK(pipe_version_lock); 91static struct rpc_wait_queue pipe_version_rpc_waitqueue; 92static DECLARE_WAIT_QUEUE_HEAD(pipe_version_waitqueue); 93 94static void gss_free_ctx(struct gss_cl_ctx *); 95static const struct rpc_pipe_ops gss_upcall_ops_v0; 96static const struct rpc_pipe_ops gss_upcall_ops_v1; 97 98static inline struct gss_cl_ctx * 99gss_get_ctx(struct gss_cl_ctx *ctx) 100{ 101 atomic_inc(&ctx->count); 102 return ctx; 103} 104 105static inline void 106gss_put_ctx(struct gss_cl_ctx *ctx) 107{ 108 if (atomic_dec_and_test(&ctx->count)) 109 gss_free_ctx(ctx); 110} 111 112/* gss_cred_set_ctx: 113 * called by gss_upcall_callback and gss_create_upcall in order 114 * to set the gss context. The actual exchange of an old context 115 * and a new one is protected by the inode->i_lock. 116 */ 117static void 118gss_cred_set_ctx(struct rpc_cred *cred, struct gss_cl_ctx *ctx) 119{ 120 struct gss_cred *gss_cred = container_of(cred, struct gss_cred, gc_base); 121 122 if (!test_bit(RPCAUTH_CRED_NEW, &cred->cr_flags)) 123 return; 124 gss_get_ctx(ctx); 125 rcu_assign_pointer(gss_cred->gc_ctx, ctx); 126 set_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags); 127 smp_mb__before_clear_bit(); 128 clear_bit(RPCAUTH_CRED_NEW, &cred->cr_flags); 129} 130 131static const void * 132simple_get_bytes(const void *p, const void *end, void *res, size_t len) 133{ 134 const void *q = (const void *)((const char *)p + len); 135 if (unlikely(q > end || q < p)) 136 return ERR_PTR(-EFAULT); 137 memcpy(res, p, len); 138 return q; 139} 140 141static inline const void * 142simple_get_netobj(const void *p, const void *end, struct xdr_netobj *dest) 143{ 144 const void *q; 145 unsigned int len; 146 147 p = simple_get_bytes(p, end, &len, sizeof(len)); 148 if (IS_ERR(p)) 149 return p; 150 q = (const void *)((const char *)p + len); 151 if (unlikely(q > end || q < p)) 152 return ERR_PTR(-EFAULT); 153 dest->data = kmemdup(p, len, GFP_NOFS); 154 if (unlikely(dest->data == NULL)) 155 return ERR_PTR(-ENOMEM); 156 dest->len = len; 157 return q; 158} 159 160static struct gss_cl_ctx * 161gss_cred_get_ctx(struct rpc_cred *cred) 162{ 163 struct gss_cred *gss_cred = container_of(cred, struct gss_cred, gc_base); 164 struct gss_cl_ctx *ctx = NULL; 165 166 rcu_read_lock(); 167 if (gss_cred->gc_ctx) 168 ctx = gss_get_ctx(gss_cred->gc_ctx); 169 rcu_read_unlock(); 170 return ctx; 171} 172 173static struct gss_cl_ctx * 174gss_alloc_context(void) 175{ 176 struct gss_cl_ctx *ctx; 177 178 ctx = kzalloc(sizeof(*ctx), GFP_NOFS); 179 if (ctx != NULL) { 180 ctx->gc_proc = RPC_GSS_PROC_DATA; 181 ctx->gc_seq = 1; /* NetApp 6.4R1 doesn't accept seq. no. 0 */ 182 spin_lock_init(&ctx->gc_seq_lock); 183 atomic_set(&ctx->count,1); 184 } 185 return ctx; 186} 187 188#define GSSD_MIN_TIMEOUT (60 * 60) 189static const void * 190gss_fill_context(const void *p, const void *end, struct gss_cl_ctx *ctx, struct gss_api_mech *gm) 191{ 192 const void *q; 193 unsigned int seclen; 194 unsigned int timeout; 195 u32 window_size; 196 int ret; 197 198 /* First unsigned int gives the lifetime (in seconds) of the cred */ 199 p = simple_get_bytes(p, end, &timeout, sizeof(timeout)); 200 if (IS_ERR(p)) 201 goto err; 202 if (timeout == 0) 203 timeout = GSSD_MIN_TIMEOUT; 204 ctx->gc_expiry = jiffies + (unsigned long)timeout * HZ * 3 / 4; 205 /* Sequence number window. Determines the maximum number of simultaneous requests */ 206 p = simple_get_bytes(p, end, &window_size, sizeof(window_size)); 207 if (IS_ERR(p)) 208 goto err; 209 ctx->gc_win = window_size; 210 /* gssd signals an error by passing ctx->gc_win = 0: */ 211 if (ctx->gc_win == 0) { 212 /* 213 * in which case, p points to an error code. Anything other 214 * than -EKEYEXPIRED gets converted to -EACCES. 215 */ 216 p = simple_get_bytes(p, end, &ret, sizeof(ret)); 217 if (!IS_ERR(p)) 218 p = (ret == -EKEYEXPIRED) ? ERR_PTR(-EKEYEXPIRED) : 219 ERR_PTR(-EACCES); 220 goto err; 221 } 222 /* copy the opaque wire context */ 223 p = simple_get_netobj(p, end, &ctx->gc_wire_ctx); 224 if (IS_ERR(p)) 225 goto err; 226 /* import the opaque security context */ 227 p = simple_get_bytes(p, end, &seclen, sizeof(seclen)); 228 if (IS_ERR(p)) 229 goto err; 230 q = (const void *)((const char *)p + seclen); 231 if (unlikely(q > end || q < p)) { 232 p = ERR_PTR(-EFAULT); 233 goto err; 234 } 235 ret = gss_import_sec_context(p, seclen, gm, &ctx->gc_gss_ctx, GFP_NOFS); 236 if (ret < 0) { 237 p = ERR_PTR(ret); 238 goto err; 239 } 240 return q; 241err: 242 dprintk("RPC: gss_fill_context returning %ld\n", -PTR_ERR(p)); 243 return p; 244} 245 246#define UPCALL_BUF_LEN 128 247 248struct gss_upcall_msg { 249 atomic_t count; 250 uid_t uid; 251 struct rpc_pipe_msg msg; 252 struct list_head list; 253 struct gss_auth *auth; 254 struct rpc_inode *inode; 255 struct rpc_wait_queue rpc_waitqueue; 256 wait_queue_head_t waitqueue; 257 struct gss_cl_ctx *ctx; 258 char databuf[UPCALL_BUF_LEN]; 259}; 260 261static int get_pipe_version(void) 262{ 263 int ret; 264 265 spin_lock(&pipe_version_lock); 266 if (pipe_version >= 0) { 267 atomic_inc(&pipe_users); 268 ret = pipe_version; 269 } else 270 ret = -EAGAIN; 271 spin_unlock(&pipe_version_lock); 272 return ret; 273} 274 275static void put_pipe_version(void) 276{ 277 if (atomic_dec_and_lock(&pipe_users, &pipe_version_lock)) { 278 pipe_version = -1; 279 spin_unlock(&pipe_version_lock); 280 } 281} 282 283static void 284gss_release_msg(struct gss_upcall_msg *gss_msg) 285{ 286 if (!atomic_dec_and_test(&gss_msg->count)) 287 return; 288 put_pipe_version(); 289 BUG_ON(!list_empty(&gss_msg->list)); 290 if (gss_msg->ctx != NULL) 291 gss_put_ctx(gss_msg->ctx); 292 rpc_destroy_wait_queue(&gss_msg->rpc_waitqueue); 293 kfree(gss_msg); 294} 295 296static struct gss_upcall_msg * 297__gss_find_upcall(struct rpc_inode *rpci, uid_t uid) 298{ 299 struct gss_upcall_msg *pos; 300 list_for_each_entry(pos, &rpci->in_downcall, list) { 301 if (pos->uid != uid) 302 continue; 303 atomic_inc(&pos->count); 304 dprintk("RPC: gss_find_upcall found msg %p\n", pos); 305 return pos; 306 } 307 dprintk("RPC: gss_find_upcall found nothing\n"); 308 return NULL; 309} 310 311/* Try to add an upcall to the pipefs queue. 312 * If an upcall owned by our uid already exists, then we return a reference 313 * to that upcall instead of adding the new upcall. 314 */ 315static inline struct gss_upcall_msg * 316gss_add_msg(struct gss_upcall_msg *gss_msg) 317{ 318 struct rpc_inode *rpci = gss_msg->inode; 319 struct inode *inode = &rpci->vfs_inode; 320 struct gss_upcall_msg *old; 321 322 spin_lock(&inode->i_lock); 323 old = __gss_find_upcall(rpci, gss_msg->uid); 324 if (old == NULL) { 325 atomic_inc(&gss_msg->count); 326 list_add(&gss_msg->list, &rpci->in_downcall); 327 } else 328 gss_msg = old; 329 spin_unlock(&inode->i_lock); 330 return gss_msg; 331} 332 333static void 334__gss_unhash_msg(struct gss_upcall_msg *gss_msg) 335{ 336 list_del_init(&gss_msg->list); 337 rpc_wake_up_status(&gss_msg->rpc_waitqueue, gss_msg->msg.errno); 338 wake_up_all(&gss_msg->waitqueue); 339 atomic_dec(&gss_msg->count); 340} 341 342static void 343gss_unhash_msg(struct gss_upcall_msg *gss_msg) 344{ 345 struct inode *inode = &gss_msg->inode->vfs_inode; 346 347 if (list_empty(&gss_msg->list)) 348 return; 349 spin_lock(&inode->i_lock); 350 if (!list_empty(&gss_msg->list)) 351 __gss_unhash_msg(gss_msg); 352 spin_unlock(&inode->i_lock); 353} 354 355static void 356gss_handle_downcall_result(struct gss_cred *gss_cred, struct gss_upcall_msg *gss_msg) 357{ 358 switch (gss_msg->msg.errno) { 359 case 0: 360 if (gss_msg->ctx == NULL) 361 break; 362 clear_bit(RPCAUTH_CRED_NEGATIVE, &gss_cred->gc_base.cr_flags); 363 gss_cred_set_ctx(&gss_cred->gc_base, gss_msg->ctx); 364 break; 365 case -EKEYEXPIRED: 366 set_bit(RPCAUTH_CRED_NEGATIVE, &gss_cred->gc_base.cr_flags); 367 } 368 gss_cred->gc_upcall_timestamp = jiffies; 369 gss_cred->gc_upcall = NULL; 370 rpc_wake_up_status(&gss_msg->rpc_waitqueue, gss_msg->msg.errno); 371} 372 373static void 374gss_upcall_callback(struct rpc_task *task) 375{ 376 struct gss_cred *gss_cred = container_of(task->tk_rqstp->rq_cred, 377 struct gss_cred, gc_base); 378 struct gss_upcall_msg *gss_msg = gss_cred->gc_upcall; 379 struct inode *inode = &gss_msg->inode->vfs_inode; 380 381 spin_lock(&inode->i_lock); 382 gss_handle_downcall_result(gss_cred, gss_msg); 383 spin_unlock(&inode->i_lock); 384 task->tk_status = gss_msg->msg.errno; 385 gss_release_msg(gss_msg); 386} 387 388static void gss_encode_v0_msg(struct gss_upcall_msg *gss_msg) 389{ 390 gss_msg->msg.data = &gss_msg->uid; 391 gss_msg->msg.len = sizeof(gss_msg->uid); 392} 393 394static void gss_encode_v1_msg(struct gss_upcall_msg *gss_msg, 395 struct rpc_clnt *clnt, int machine_cred) 396{ 397 struct gss_api_mech *mech = gss_msg->auth->mech; 398 char *p = gss_msg->databuf; 399 int len = 0; 400 401 gss_msg->msg.len = sprintf(gss_msg->databuf, "mech=%s uid=%d ", 402 mech->gm_name, 403 gss_msg->uid); 404 p += gss_msg->msg.len; 405 if (clnt->cl_principal) { 406 len = sprintf(p, "target=%s ", clnt->cl_principal); 407 p += len; 408 gss_msg->msg.len += len; 409 } 410 if (machine_cred) { 411 len = sprintf(p, "service=* "); 412 p += len; 413 gss_msg->msg.len += len; 414 } else if (!strcmp(clnt->cl_program->name, "nfs4_cb")) { 415 len = sprintf(p, "service=nfs "); 416 p += len; 417 gss_msg->msg.len += len; 418 } 419 if (mech->gm_upcall_enctypes) { 420 len = sprintf(p, mech->gm_upcall_enctypes); 421 p += len; 422 gss_msg->msg.len += len; 423 } 424 len = sprintf(p, "\n"); 425 gss_msg->msg.len += len; 426 427 gss_msg->msg.data = gss_msg->databuf; 428 BUG_ON(gss_msg->msg.len > UPCALL_BUF_LEN); 429} 430 431static void gss_encode_msg(struct gss_upcall_msg *gss_msg, 432 struct rpc_clnt *clnt, int machine_cred) 433{ 434 if (pipe_version == 0) 435 gss_encode_v0_msg(gss_msg); 436 else /* pipe_version == 1 */ 437 gss_encode_v1_msg(gss_msg, clnt, machine_cred); 438} 439 440static inline struct gss_upcall_msg * 441gss_alloc_msg(struct gss_auth *gss_auth, uid_t uid, struct rpc_clnt *clnt, 442 int machine_cred) 443{ 444 struct gss_upcall_msg *gss_msg; 445 int vers; 446 447 gss_msg = kzalloc(sizeof(*gss_msg), GFP_NOFS); 448 if (gss_msg == NULL) 449 return ERR_PTR(-ENOMEM); 450 vers = get_pipe_version(); 451 if (vers < 0) { 452 kfree(gss_msg); 453 return ERR_PTR(vers); 454 } 455 gss_msg->inode = RPC_I(gss_auth->dentry[vers]->d_inode); 456 INIT_LIST_HEAD(&gss_msg->list); 457 rpc_init_wait_queue(&gss_msg->rpc_waitqueue, "RPCSEC_GSS upcall waitq"); 458 init_waitqueue_head(&gss_msg->waitqueue); 459 atomic_set(&gss_msg->count, 1); 460 gss_msg->uid = uid; 461 gss_msg->auth = gss_auth; 462 gss_encode_msg(gss_msg, clnt, machine_cred); 463 return gss_msg; 464} 465 466static struct gss_upcall_msg * 467gss_setup_upcall(struct rpc_clnt *clnt, struct gss_auth *gss_auth, struct rpc_cred *cred) 468{ 469 struct gss_cred *gss_cred = container_of(cred, 470 struct gss_cred, gc_base); 471 struct gss_upcall_msg *gss_new, *gss_msg; 472 uid_t uid = cred->cr_uid; 473 474 gss_new = gss_alloc_msg(gss_auth, uid, clnt, gss_cred->gc_machine_cred); 475 if (IS_ERR(gss_new)) 476 return gss_new; 477 gss_msg = gss_add_msg(gss_new); 478 if (gss_msg == gss_new) { 479 struct inode *inode = &gss_new->inode->vfs_inode; 480 int res = rpc_queue_upcall(inode, &gss_new->msg); 481 if (res) { 482 gss_unhash_msg(gss_new); 483 gss_msg = ERR_PTR(res); 484 } 485 } else 486 gss_release_msg(gss_new); 487 return gss_msg; 488} 489 490static void warn_gssd(void) 491{ 492 static unsigned long ratelimit; 493 unsigned long now = jiffies; 494 495 if (time_after(now, ratelimit)) { 496 printk(KERN_WARNING "RPC: AUTH_GSS upcall timed out.\n" 497 "Please check user daemon is running.\n"); 498 ratelimit = now + 15*HZ; 499 } 500} 501 502static inline int 503gss_refresh_upcall(struct rpc_task *task) 504{ 505 struct rpc_cred *cred = task->tk_rqstp->rq_cred; 506 struct gss_auth *gss_auth = container_of(cred->cr_auth, 507 struct gss_auth, rpc_auth); 508 struct gss_cred *gss_cred = container_of(cred, 509 struct gss_cred, gc_base); 510 struct gss_upcall_msg *gss_msg; 511 struct inode *inode; 512 int err = 0; 513 514 dprintk("RPC: %5u gss_refresh_upcall for uid %u\n", task->tk_pid, 515 cred->cr_uid); 516 gss_msg = gss_setup_upcall(task->tk_client, gss_auth, cred); 517 if (PTR_ERR(gss_msg) == -EAGAIN) { 518 /* XXX: warning on the first, under the assumption we 519 * shouldn't normally hit this case on a refresh. */ 520 warn_gssd(); 521 task->tk_timeout = 15*HZ; 522 rpc_sleep_on(&pipe_version_rpc_waitqueue, task, NULL); 523 return 0; 524 } 525 if (IS_ERR(gss_msg)) { 526 err = PTR_ERR(gss_msg); 527 goto out; 528 } 529 inode = &gss_msg->inode->vfs_inode; 530 spin_lock(&inode->i_lock); 531 if (gss_cred->gc_upcall != NULL) 532 rpc_sleep_on(&gss_cred->gc_upcall->rpc_waitqueue, task, NULL); 533 else if (gss_msg->ctx == NULL && gss_msg->msg.errno >= 0) { 534 task->tk_timeout = 0; 535 gss_cred->gc_upcall = gss_msg; 536 /* gss_upcall_callback will release the reference to gss_upcall_msg */ 537 atomic_inc(&gss_msg->count); 538 rpc_sleep_on(&gss_msg->rpc_waitqueue, task, gss_upcall_callback); 539 } else { 540 gss_handle_downcall_result(gss_cred, gss_msg); 541 err = gss_msg->msg.errno; 542 } 543 spin_unlock(&inode->i_lock); 544 gss_release_msg(gss_msg); 545out: 546 dprintk("RPC: %5u gss_refresh_upcall for uid %u result %d\n", 547 task->tk_pid, cred->cr_uid, err); 548 return err; 549} 550 551static inline int 552gss_create_upcall(struct gss_auth *gss_auth, struct gss_cred *gss_cred) 553{ 554 struct inode *inode; 555 struct rpc_cred *cred = &gss_cred->gc_base; 556 struct gss_upcall_msg *gss_msg; 557 DEFINE_WAIT(wait); 558 int err = 0; 559 560 dprintk("RPC: gss_upcall for uid %u\n", cred->cr_uid); 561retry: 562 gss_msg = gss_setup_upcall(gss_auth->client, gss_auth, cred); 563 if (PTR_ERR(gss_msg) == -EAGAIN) { 564 err = wait_event_interruptible_timeout(pipe_version_waitqueue, 565 pipe_version >= 0, 15*HZ); 566 if (err) 567 goto out; 568 if (pipe_version < 0) 569 warn_gssd(); 570 goto retry; 571 } 572 if (IS_ERR(gss_msg)) { 573 err = PTR_ERR(gss_msg); 574 goto out; 575 } 576 inode = &gss_msg->inode->vfs_inode; 577 for (;;) { 578 prepare_to_wait(&gss_msg->waitqueue, &wait, TASK_INTERRUPTIBLE); 579 spin_lock(&inode->i_lock); 580 if (gss_msg->ctx != NULL || gss_msg->msg.errno < 0) { 581 break; 582 } 583 spin_unlock(&inode->i_lock); 584 if (signalled()) { 585 err = -ERESTARTSYS; 586 goto out_intr; 587 } 588 schedule(); 589 } 590 if (gss_msg->ctx) 591 gss_cred_set_ctx(cred, gss_msg->ctx); 592 else 593 err = gss_msg->msg.errno; 594 spin_unlock(&inode->i_lock); 595out_intr: 596 finish_wait(&gss_msg->waitqueue, &wait); 597 gss_release_msg(gss_msg); 598out: 599 dprintk("RPC: gss_create_upcall for uid %u result %d\n", 600 cred->cr_uid, err); 601 return err; 602} 603 604static ssize_t 605gss_pipe_upcall(struct file *filp, struct rpc_pipe_msg *msg, 606 char __user *dst, size_t buflen) 607{ 608 char *data = (char *)msg->data + msg->copied; 609 size_t mlen = min(msg->len, buflen); 610 unsigned long left; 611 612 left = copy_to_user(dst, data, mlen); 613 if (left == mlen) { 614 msg->errno = -EFAULT; 615 return -EFAULT; 616 } 617 618 mlen -= left; 619 msg->copied += mlen; 620 msg->errno = 0; 621 return mlen; 622} 623 624#define MSG_BUF_MAXSIZE 1024 625 626static ssize_t 627gss_pipe_downcall(struct file *filp, const char __user *src, size_t mlen) 628{ 629 const void *p, *end; 630 void *buf; 631 struct gss_upcall_msg *gss_msg; 632 struct inode *inode = filp->f_path.dentry->d_inode; 633 struct gss_cl_ctx *ctx; 634 uid_t uid; 635 ssize_t err = -EFBIG; 636 637 if (mlen > MSG_BUF_MAXSIZE) 638 goto out; 639 err = -ENOMEM; 640 buf = kmalloc(mlen, GFP_NOFS); 641 if (!buf) 642 goto out; 643 644 err = -EFAULT; 645 if (copy_from_user(buf, src, mlen)) 646 goto err; 647 648 end = (const void *)((char *)buf + mlen); 649 p = simple_get_bytes(buf, end, &uid, sizeof(uid)); 650 if (IS_ERR(p)) { 651 err = PTR_ERR(p); 652 goto err; 653 } 654 655 err = -ENOMEM; 656 ctx = gss_alloc_context(); 657 if (ctx == NULL) 658 goto err; 659 660 err = -ENOENT; 661 /* Find a matching upcall */ 662 spin_lock(&inode->i_lock); 663 gss_msg = __gss_find_upcall(RPC_I(inode), uid); 664 if (gss_msg == NULL) { 665 spin_unlock(&inode->i_lock); 666 goto err_put_ctx; 667 } 668 list_del_init(&gss_msg->list); 669 spin_unlock(&inode->i_lock); 670 671 p = gss_fill_context(p, end, ctx, gss_msg->auth->mech); 672 if (IS_ERR(p)) { 673 err = PTR_ERR(p); 674 switch (err) { 675 case -EACCES: 676 case -EKEYEXPIRED: 677 gss_msg->msg.errno = err; 678 err = mlen; 679 break; 680 case -EFAULT: 681 case -ENOMEM: 682 case -EINVAL: 683 case -ENOSYS: 684 gss_msg->msg.errno = -EAGAIN; 685 break; 686 default: 687 printk(KERN_CRIT "%s: bad return from " 688 "gss_fill_context: %zd\n", __func__, err); 689 BUG(); 690 } 691 goto err_release_msg; 692 } 693 gss_msg->ctx = gss_get_ctx(ctx); 694 err = mlen; 695 696err_release_msg: 697 spin_lock(&inode->i_lock); 698 __gss_unhash_msg(gss_msg); 699 spin_unlock(&inode->i_lock); 700 gss_release_msg(gss_msg); 701err_put_ctx: 702 gss_put_ctx(ctx); 703err: 704 kfree(buf); 705out: 706 dprintk("RPC: gss_pipe_downcall returning %Zd\n", err); 707 return err; 708} 709 710static int gss_pipe_open(struct inode *inode, int new_version) 711{ 712 int ret = 0; 713 714 spin_lock(&pipe_version_lock); 715 if (pipe_version < 0) { 716 /* First open of any gss pipe determines the version: */ 717 pipe_version = new_version; 718 rpc_wake_up(&pipe_version_rpc_waitqueue); 719 wake_up(&pipe_version_waitqueue); 720 } else if (pipe_version != new_version) { 721 /* Trying to open a pipe of a different version */ 722 ret = -EBUSY; 723 goto out; 724 } 725 atomic_inc(&pipe_users); 726out: 727 spin_unlock(&pipe_version_lock); 728 return ret; 729 730} 731 732static int gss_pipe_open_v0(struct inode *inode) 733{ 734 return gss_pipe_open(inode, 0); 735} 736 737static int gss_pipe_open_v1(struct inode *inode) 738{ 739 return gss_pipe_open(inode, 1); 740} 741 742static void 743gss_pipe_release(struct inode *inode) 744{ 745 struct rpc_inode *rpci = RPC_I(inode); 746 struct gss_upcall_msg *gss_msg; 747 748restart: 749 spin_lock(&inode->i_lock); 750 list_for_each_entry(gss_msg, &rpci->in_downcall, list) { 751 752 if (!list_empty(&gss_msg->msg.list)) 753 continue; 754 gss_msg->msg.errno = -EPIPE; 755 atomic_inc(&gss_msg->count); 756 __gss_unhash_msg(gss_msg); 757 spin_unlock(&inode->i_lock); 758 gss_release_msg(gss_msg); 759 goto restart; 760 } 761 spin_unlock(&inode->i_lock); 762 763 put_pipe_version(); 764} 765 766static void 767gss_pipe_destroy_msg(struct rpc_pipe_msg *msg) 768{ 769 struct gss_upcall_msg *gss_msg = container_of(msg, struct gss_upcall_msg, msg); 770 771 if (msg->errno < 0) { 772 dprintk("RPC: gss_pipe_destroy_msg releasing msg %p\n", 773 gss_msg); 774 atomic_inc(&gss_msg->count); 775 gss_unhash_msg(gss_msg); 776 if (msg->errno == -ETIMEDOUT) 777 warn_gssd(); 778 gss_release_msg(gss_msg); 779 } 780} 781 782/* 783 * NOTE: we have the opportunity to use different 784 * parameters based on the input flavor (which must be a pseudoflavor) 785 */ 786static struct rpc_auth * 787gss_create(struct rpc_clnt *clnt, rpc_authflavor_t flavor) 788{ 789 struct gss_auth *gss_auth; 790 struct rpc_auth * auth; 791 int err = -ENOMEM; /* XXX? */ 792 793 dprintk("RPC: creating GSS authenticator for client %p\n", clnt); 794 795 if (!try_module_get(THIS_MODULE)) 796 return ERR_PTR(err); 797 if (!(gss_auth = kmalloc(sizeof(*gss_auth), GFP_KERNEL))) 798 goto out_dec; 799 gss_auth->client = clnt; 800 err = -EINVAL; 801 gss_auth->mech = gss_mech_get_by_pseudoflavor(flavor); 802 if (!gss_auth->mech) { 803 printk(KERN_WARNING "%s: Pseudoflavor %d not found!\n", 804 __func__, flavor); 805 goto err_free; 806 } 807 gss_auth->service = gss_pseudoflavor_to_service(gss_auth->mech, flavor); 808 if (gss_auth->service == 0) 809 goto err_put_mech; 810 auth = &gss_auth->rpc_auth; 811 auth->au_cslack = GSS_CRED_SLACK >> 2; 812 auth->au_rslack = GSS_VERF_SLACK >> 2; 813 auth->au_ops = &authgss_ops; 814 auth->au_flavor = flavor; 815 atomic_set(&auth->au_count, 1); 816 kref_init(&gss_auth->kref); 817 818 /* 819 * Note: if we created the old pipe first, then someone who 820 * examined the directory at the right moment might conclude 821 * that we supported only the old pipe. So we instead create 822 * the new pipe first. 823 */ 824 gss_auth->dentry[1] = rpc_mkpipe(clnt->cl_path.dentry, 825 "gssd", 826 clnt, &gss_upcall_ops_v1, 827 RPC_PIPE_WAIT_FOR_OPEN); 828 if (IS_ERR(gss_auth->dentry[1])) { 829 err = PTR_ERR(gss_auth->dentry[1]); 830 goto err_put_mech; 831 } 832 833 gss_auth->dentry[0] = rpc_mkpipe(clnt->cl_path.dentry, 834 gss_auth->mech->gm_name, 835 clnt, &gss_upcall_ops_v0, 836 RPC_PIPE_WAIT_FOR_OPEN); 837 if (IS_ERR(gss_auth->dentry[0])) { 838 err = PTR_ERR(gss_auth->dentry[0]); 839 goto err_unlink_pipe_1; 840 } 841 err = rpcauth_init_credcache(auth); 842 if (err) 843 goto err_unlink_pipe_0; 844 845 return auth; 846err_unlink_pipe_0: 847 rpc_unlink(gss_auth->dentry[0]); 848err_unlink_pipe_1: 849 rpc_unlink(gss_auth->dentry[1]); 850err_put_mech: 851 gss_mech_put(gss_auth->mech); 852err_free: 853 kfree(gss_auth); 854out_dec: 855 module_put(THIS_MODULE); 856 return ERR_PTR(err); 857} 858 859static void 860gss_free(struct gss_auth *gss_auth) 861{ 862 rpc_unlink(gss_auth->dentry[1]); 863 rpc_unlink(gss_auth->dentry[0]); 864 gss_mech_put(gss_auth->mech); 865 866 kfree(gss_auth); 867 module_put(THIS_MODULE); 868} 869 870static void 871gss_free_callback(struct kref *kref) 872{ 873 struct gss_auth *gss_auth = container_of(kref, struct gss_auth, kref); 874 875 gss_free(gss_auth); 876} 877 878static void 879gss_destroy(struct rpc_auth *auth) 880{ 881 struct gss_auth *gss_auth; 882 883 dprintk("RPC: destroying GSS authenticator %p flavor %d\n", 884 auth, auth->au_flavor); 885 886 rpcauth_destroy_credcache(auth); 887 888 gss_auth = container_of(auth, struct gss_auth, rpc_auth); 889 kref_put(&gss_auth->kref, gss_free_callback); 890} 891 892/* 893 * gss_destroying_context will cause the RPCSEC_GSS to send a NULL RPC call 894 * to the server with the GSS control procedure field set to 895 * RPC_GSS_PROC_DESTROY. This should normally cause the server to release 896 * all RPCSEC_GSS state associated with that context. 897 */ 898static int 899gss_destroying_context(struct rpc_cred *cred) 900{ 901 struct gss_cred *gss_cred = container_of(cred, struct gss_cred, gc_base); 902 struct gss_auth *gss_auth = container_of(cred->cr_auth, struct gss_auth, rpc_auth); 903 struct rpc_task *task; 904 905 if (gss_cred->gc_ctx == NULL || 906 test_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags) == 0) 907 return 0; 908 909 gss_cred->gc_ctx->gc_proc = RPC_GSS_PROC_DESTROY; 910 cred->cr_ops = &gss_nullops; 911 912 /* Take a reference to ensure the cred will be destroyed either 913 * by the RPC call or by the put_rpccred() below */ 914 get_rpccred(cred); 915 916 task = rpc_call_null(gss_auth->client, cred, RPC_TASK_ASYNC|RPC_TASK_SOFT); 917 if (!IS_ERR(task)) 918 rpc_put_task(task); 919 920 put_rpccred(cred); 921 return 1; 922} 923 924/* gss_destroy_cred (and gss_free_ctx) are used to clean up after failure 925 * to create a new cred or context, so they check that things have been 926 * allocated before freeing them. */ 927static void 928gss_do_free_ctx(struct gss_cl_ctx *ctx) 929{ 930 dprintk("RPC: gss_free_ctx\n"); 931 932 gss_delete_sec_context(&ctx->gc_gss_ctx); 933 kfree(ctx->gc_wire_ctx.data); 934 kfree(ctx); 935} 936 937static void 938gss_free_ctx_callback(struct rcu_head *head) 939{ 940 struct gss_cl_ctx *ctx = container_of(head, struct gss_cl_ctx, gc_rcu); 941 gss_do_free_ctx(ctx); 942} 943 944static void 945gss_free_ctx(struct gss_cl_ctx *ctx) 946{ 947 call_rcu(&ctx->gc_rcu, gss_free_ctx_callback); 948} 949 950static void 951gss_free_cred(struct gss_cred *gss_cred) 952{ 953 dprintk("RPC: gss_free_cred %p\n", gss_cred); 954 kfree(gss_cred); 955} 956 957static void 958gss_free_cred_callback(struct rcu_head *head) 959{ 960 struct gss_cred *gss_cred = container_of(head, struct gss_cred, gc_base.cr_rcu); 961 gss_free_cred(gss_cred); 962} 963 964static void 965gss_destroy_nullcred(struct rpc_cred *cred) 966{ 967 struct gss_cred *gss_cred = container_of(cred, struct gss_cred, gc_base); 968 struct gss_auth *gss_auth = container_of(cred->cr_auth, struct gss_auth, rpc_auth); 969 struct gss_cl_ctx *ctx = gss_cred->gc_ctx; 970 971 rcu_assign_pointer(gss_cred->gc_ctx, NULL); 972 call_rcu(&cred->cr_rcu, gss_free_cred_callback); 973 if (ctx) 974 gss_put_ctx(ctx); 975 kref_put(&gss_auth->kref, gss_free_callback); 976} 977 978static void 979gss_destroy_cred(struct rpc_cred *cred) 980{ 981 982 if (gss_destroying_context(cred)) 983 return; 984 gss_destroy_nullcred(cred); 985} 986 987/* 988 * Lookup RPCSEC_GSS cred for the current process 989 */ 990static struct rpc_cred * 991gss_lookup_cred(struct rpc_auth *auth, struct auth_cred *acred, int flags) 992{ 993 return rpcauth_lookup_credcache(auth, acred, flags); 994} 995 996static struct rpc_cred * 997gss_create_cred(struct rpc_auth *auth, struct auth_cred *acred, int flags) 998{ 999 struct gss_auth *gss_auth = container_of(auth, struct gss_auth, rpc_auth); 1000 struct gss_cred *cred = NULL; 1001 int err = -ENOMEM; 1002 1003 dprintk("RPC: gss_create_cred for uid %d, flavor %d\n", 1004 acred->uid, auth->au_flavor); 1005 1006 if (!(cred = kzalloc(sizeof(*cred), GFP_NOFS))) 1007 goto out_err; 1008 1009 rpcauth_init_cred(&cred->gc_base, acred, auth, &gss_credops); 1010 /* 1011 * Note: in order to force a call to call_refresh(), we deliberately 1012 * fail to flag the credential as RPCAUTH_CRED_UPTODATE. 1013 */ 1014 cred->gc_base.cr_flags = 1UL << RPCAUTH_CRED_NEW; 1015 cred->gc_service = gss_auth->service; 1016 cred->gc_machine_cred = acred->machine_cred; 1017 kref_get(&gss_auth->kref); 1018 return &cred->gc_base; 1019 1020out_err: 1021 dprintk("RPC: gss_create_cred failed with error %d\n", err); 1022 return ERR_PTR(err); 1023} 1024 1025static int 1026gss_cred_init(struct rpc_auth *auth, struct rpc_cred *cred) 1027{ 1028 struct gss_auth *gss_auth = container_of(auth, struct gss_auth, rpc_auth); 1029 struct gss_cred *gss_cred = container_of(cred,struct gss_cred, gc_base); 1030 int err; 1031 1032 do { 1033 err = gss_create_upcall(gss_auth, gss_cred); 1034 } while (err == -EAGAIN); 1035 return err; 1036} 1037 1038static int 1039gss_match(struct auth_cred *acred, struct rpc_cred *rc, int flags) 1040{ 1041 struct gss_cred *gss_cred = container_of(rc, struct gss_cred, gc_base); 1042 1043 if (test_bit(RPCAUTH_CRED_NEW, &rc->cr_flags)) 1044 goto out; 1045 /* Don't match with creds that have expired. */ 1046 if (time_after(jiffies, gss_cred->gc_ctx->gc_expiry)) 1047 return 0; 1048 if (!test_bit(RPCAUTH_CRED_UPTODATE, &rc->cr_flags)) 1049 return 0; 1050out: 1051 if (acred->machine_cred != gss_cred->gc_machine_cred) 1052 return 0; 1053 return rc->cr_uid == acred->uid; 1054} 1055 1056/* 1057* Marshal credentials. 1058* Maybe we should keep a cached credential for performance reasons. 1059*/ 1060static __be32 * 1061gss_marshal(struct rpc_task *task, __be32 *p) 1062{ 1063 struct rpc_rqst *req = task->tk_rqstp; 1064 struct rpc_cred *cred = req->rq_cred; 1065 struct gss_cred *gss_cred = container_of(cred, struct gss_cred, 1066 gc_base); 1067 struct gss_cl_ctx *ctx = gss_cred_get_ctx(cred); 1068 __be32 *cred_len; 1069 u32 maj_stat = 0; 1070 struct xdr_netobj mic; 1071 struct kvec iov; 1072 struct xdr_buf verf_buf; 1073 1074 dprintk("RPC: %5u gss_marshal\n", task->tk_pid); 1075 1076 *p++ = htonl(RPC_AUTH_GSS); 1077 cred_len = p++; 1078 1079 spin_lock(&ctx->gc_seq_lock); 1080 req->rq_seqno = ctx->gc_seq++; 1081 spin_unlock(&ctx->gc_seq_lock); 1082 1083 *p++ = htonl((u32) RPC_GSS_VERSION); 1084 *p++ = htonl((u32) ctx->gc_proc); 1085 *p++ = htonl((u32) req->rq_seqno); 1086 *p++ = htonl((u32) gss_cred->gc_service); 1087 p = xdr_encode_netobj(p, &ctx->gc_wire_ctx); 1088 *cred_len = htonl((p - (cred_len + 1)) << 2); 1089 1090 /* We compute the checksum for the verifier over the xdr-encoded bytes 1091 * starting with the xid and ending at the end of the credential: */ 1092 iov.iov_base = xprt_skip_transport_header(task->tk_xprt, 1093 req->rq_snd_buf.head[0].iov_base); 1094 iov.iov_len = (u8 *)p - (u8 *)iov.iov_base; 1095 xdr_buf_from_iov(&iov, &verf_buf); 1096 1097 /* set verifier flavor*/ 1098 *p++ = htonl(RPC_AUTH_GSS); 1099 1100 mic.data = (u8 *)(p + 1); 1101 maj_stat = gss_get_mic(ctx->gc_gss_ctx, &verf_buf, &mic); 1102 if (maj_stat == GSS_S_CONTEXT_EXPIRED) { 1103 clear_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags); 1104 } else if (maj_stat != 0) { 1105 printk("gss_marshal: gss_get_mic FAILED (%d)\n", maj_stat); 1106 goto out_put_ctx; 1107 } 1108 p = xdr_encode_opaque(p, NULL, mic.len); 1109 gss_put_ctx(ctx); 1110 return p; 1111out_put_ctx: 1112 gss_put_ctx(ctx); 1113 return NULL; 1114} 1115 1116static int gss_renew_cred(struct rpc_task *task) 1117{ 1118 struct rpc_cred *oldcred = task->tk_rqstp->rq_cred; 1119 struct gss_cred *gss_cred = container_of(oldcred, 1120 struct gss_cred, 1121 gc_base); 1122 struct rpc_auth *auth = oldcred->cr_auth; 1123 struct auth_cred acred = { 1124 .uid = oldcred->cr_uid, 1125 .machine_cred = gss_cred->gc_machine_cred, 1126 }; 1127 struct rpc_cred *new; 1128 1129 new = gss_lookup_cred(auth, &acred, RPCAUTH_LOOKUP_NEW); 1130 if (IS_ERR(new)) 1131 return PTR_ERR(new); 1132 task->tk_rqstp->rq_cred = new; 1133 put_rpccred(oldcred); 1134 return 0; 1135} 1136 1137static int gss_cred_is_negative_entry(struct rpc_cred *cred) 1138{ 1139 if (test_bit(RPCAUTH_CRED_NEGATIVE, &cred->cr_flags)) { 1140 unsigned long now = jiffies; 1141 unsigned long begin, expire; 1142 struct gss_cred *gss_cred; 1143 1144 gss_cred = container_of(cred, struct gss_cred, gc_base); 1145 begin = gss_cred->gc_upcall_timestamp; 1146 expire = begin + gss_expired_cred_retry_delay * HZ; 1147 1148 if (time_in_range_open(now, begin, expire)) 1149 return 1; 1150 } 1151 return 0; 1152} 1153 1154/* 1155* Refresh credentials. XXX - finish 1156*/ 1157static int 1158gss_refresh(struct rpc_task *task) 1159{ 1160 struct rpc_cred *cred = task->tk_rqstp->rq_cred; 1161 int ret = 0; 1162 1163 if (gss_cred_is_negative_entry(cred)) 1164 return -EKEYEXPIRED; 1165 1166 if (!test_bit(RPCAUTH_CRED_NEW, &cred->cr_flags) && 1167 !test_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags)) { 1168 ret = gss_renew_cred(task); 1169 if (ret < 0) 1170 goto out; 1171 cred = task->tk_rqstp->rq_cred; 1172 } 1173 1174 if (test_bit(RPCAUTH_CRED_NEW, &cred->cr_flags)) 1175 ret = gss_refresh_upcall(task); 1176out: 1177 return ret; 1178} 1179 1180/* Dummy refresh routine: used only when destroying the context */ 1181static int 1182gss_refresh_null(struct rpc_task *task) 1183{ 1184 return -EACCES; 1185} 1186 1187static __be32 * 1188gss_validate(struct rpc_task *task, __be32 *p) 1189{ 1190 struct rpc_cred *cred = task->tk_rqstp->rq_cred; 1191 struct gss_cl_ctx *ctx = gss_cred_get_ctx(cred); 1192 __be32 seq; 1193 struct kvec iov; 1194 struct xdr_buf verf_buf; 1195 struct xdr_netobj mic; 1196 u32 flav,len; 1197 u32 maj_stat; 1198 1199 dprintk("RPC: %5u gss_validate\n", task->tk_pid); 1200 1201 flav = ntohl(*p++); 1202 if ((len = ntohl(*p++)) > RPC_MAX_AUTH_SIZE) 1203 goto out_bad; 1204 if (flav != RPC_AUTH_GSS) 1205 goto out_bad; 1206 seq = htonl(task->tk_rqstp->rq_seqno); 1207 iov.iov_base = &seq; 1208 iov.iov_len = sizeof(seq); 1209 xdr_buf_from_iov(&iov, &verf_buf); 1210 mic.data = (u8 *)p; 1211 mic.len = len; 1212 1213 maj_stat = gss_verify_mic(ctx->gc_gss_ctx, &verf_buf, &mic); 1214 if (maj_stat == GSS_S_CONTEXT_EXPIRED) 1215 clear_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags); 1216 if (maj_stat) { 1217 dprintk("RPC: %5u gss_validate: gss_verify_mic returned " 1218 "error 0x%08x\n", task->tk_pid, maj_stat); 1219 goto out_bad; 1220 } 1221 /* We leave it to unwrap to calculate au_rslack. For now we just 1222 * calculate the length of the verifier: */ 1223 cred->cr_auth->au_verfsize = XDR_QUADLEN(len) + 2; 1224 gss_put_ctx(ctx); 1225 dprintk("RPC: %5u gss_validate: gss_verify_mic succeeded.\n", 1226 task->tk_pid); 1227 return p + XDR_QUADLEN(len); 1228out_bad: 1229 gss_put_ctx(ctx); 1230 dprintk("RPC: %5u gss_validate failed.\n", task->tk_pid); 1231 return NULL; 1232} 1233 1234static void gss_wrap_req_encode(kxdreproc_t encode, struct rpc_rqst *rqstp, 1235 __be32 *p, void *obj) 1236{ 1237 struct xdr_stream xdr; 1238 1239 xdr_init_encode(&xdr, &rqstp->rq_snd_buf, p); 1240 encode(rqstp, &xdr, obj); 1241} 1242 1243static inline int 1244gss_wrap_req_integ(struct rpc_cred *cred, struct gss_cl_ctx *ctx, 1245 kxdreproc_t encode, struct rpc_rqst *rqstp, 1246 __be32 *p, void *obj) 1247{ 1248 struct xdr_buf *snd_buf = &rqstp->rq_snd_buf; 1249 struct xdr_buf integ_buf; 1250 __be32 *integ_len = NULL; 1251 struct xdr_netobj mic; 1252 u32 offset; 1253 __be32 *q; 1254 struct kvec *iov; 1255 u32 maj_stat = 0; 1256 int status = -EIO; 1257 1258 integ_len = p++; 1259 offset = (u8 *)p - (u8 *)snd_buf->head[0].iov_base; 1260 *p++ = htonl(rqstp->rq_seqno); 1261 1262 gss_wrap_req_encode(encode, rqstp, p, obj); 1263 1264 if (xdr_buf_subsegment(snd_buf, &integ_buf, 1265 offset, snd_buf->len - offset)) 1266 return status; 1267 *integ_len = htonl(integ_buf.len); 1268 1269 /* guess whether we're in the head or the tail: */ 1270 if (snd_buf->page_len || snd_buf->tail[0].iov_len) 1271 iov = snd_buf->tail; 1272 else 1273 iov = snd_buf->head; 1274 p = iov->iov_base + iov->iov_len; 1275 mic.data = (u8 *)(p + 1); 1276 1277 maj_stat = gss_get_mic(ctx->gc_gss_ctx, &integ_buf, &mic); 1278 status = -EIO; /* XXX? */ 1279 if (maj_stat == GSS_S_CONTEXT_EXPIRED) 1280 clear_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags); 1281 else if (maj_stat) 1282 return status; 1283 q = xdr_encode_opaque(p, NULL, mic.len); 1284 1285 offset = (u8 *)q - (u8 *)p; 1286 iov->iov_len += offset; 1287 snd_buf->len += offset; 1288 return 0; 1289} 1290 1291static void 1292priv_release_snd_buf(struct rpc_rqst *rqstp) 1293{ 1294 int i; 1295 1296 for (i=0; i < rqstp->rq_enc_pages_num; i++) 1297 __free_page(rqstp->rq_enc_pages[i]); 1298 kfree(rqstp->rq_enc_pages); 1299} 1300 1301static int 1302alloc_enc_pages(struct rpc_rqst *rqstp) 1303{ 1304 struct xdr_buf *snd_buf = &rqstp->rq_snd_buf; 1305 int first, last, i; 1306 1307 if (snd_buf->page_len == 0) { 1308 rqstp->rq_enc_pages_num = 0; 1309 return 0; 1310 } 1311 1312 first = snd_buf->page_base >> PAGE_CACHE_SHIFT; 1313 last = (snd_buf->page_base + snd_buf->page_len - 1) >> PAGE_CACHE_SHIFT; 1314 rqstp->rq_enc_pages_num = last - first + 1 + 1; 1315 rqstp->rq_enc_pages 1316 = kmalloc(rqstp->rq_enc_pages_num * sizeof(struct page *), 1317 GFP_NOFS); 1318 if (!rqstp->rq_enc_pages) 1319 goto out; 1320 for (i=0; i < rqstp->rq_enc_pages_num; i++) { 1321 rqstp->rq_enc_pages[i] = alloc_page(GFP_NOFS); 1322 if (rqstp->rq_enc_pages[i] == NULL) 1323 goto out_free; 1324 } 1325 rqstp->rq_release_snd_buf = priv_release_snd_buf; 1326 return 0; 1327out_free: 1328 rqstp->rq_enc_pages_num = i; 1329 priv_release_snd_buf(rqstp); 1330out: 1331 return -EAGAIN; 1332} 1333 1334static inline int 1335gss_wrap_req_priv(struct rpc_cred *cred, struct gss_cl_ctx *ctx, 1336 kxdreproc_t encode, struct rpc_rqst *rqstp, 1337 __be32 *p, void *obj) 1338{ 1339 struct xdr_buf *snd_buf = &rqstp->rq_snd_buf; 1340 u32 offset; 1341 u32 maj_stat; 1342 int status; 1343 __be32 *opaque_len; 1344 struct page **inpages; 1345 int first; 1346 int pad; 1347 struct kvec *iov; 1348 char *tmp; 1349 1350 opaque_len = p++; 1351 offset = (u8 *)p - (u8 *)snd_buf->head[0].iov_base; 1352 *p++ = htonl(rqstp->rq_seqno); 1353 1354 gss_wrap_req_encode(encode, rqstp, p, obj); 1355 1356 status = alloc_enc_pages(rqstp); 1357 if (status) 1358 return status; 1359 first = snd_buf->page_base >> PAGE_CACHE_SHIFT; 1360 inpages = snd_buf->pages + first; 1361 snd_buf->pages = rqstp->rq_enc_pages; 1362 snd_buf->page_base -= first << PAGE_CACHE_SHIFT; 1363 /* 1364 * Give the tail its own page, in case we need extra space in the 1365 * head when wrapping: 1366 * 1367 * call_allocate() allocates twice the slack space required 1368 * by the authentication flavor to rq_callsize. 1369 * For GSS, slack is GSS_CRED_SLACK. 1370 */ 1371 if (snd_buf->page_len || snd_buf->tail[0].iov_len) { 1372 tmp = page_address(rqstp->rq_enc_pages[rqstp->rq_enc_pages_num - 1]); 1373 memcpy(tmp, snd_buf->tail[0].iov_base, snd_buf->tail[0].iov_len); 1374 snd_buf->tail[0].iov_base = tmp; 1375 } 1376 maj_stat = gss_wrap(ctx->gc_gss_ctx, offset, snd_buf, inpages); 1377 /* slack space should prevent this ever happening: */ 1378 BUG_ON(snd_buf->len > snd_buf->buflen); 1379 status = -EIO; 1380 /* We're assuming that when GSS_S_CONTEXT_EXPIRED, the encryption was 1381 * done anyway, so it's safe to put the request on the wire: */ 1382 if (maj_stat == GSS_S_CONTEXT_EXPIRED) 1383 clear_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags); 1384 else if (maj_stat) 1385 return status; 1386 1387 *opaque_len = htonl(snd_buf->len - offset); 1388 /* guess whether we're in the head or the tail: */ 1389 if (snd_buf->page_len || snd_buf->tail[0].iov_len) 1390 iov = snd_buf->tail; 1391 else 1392 iov = snd_buf->head; 1393 p = iov->iov_base + iov->iov_len; 1394 pad = 3 - ((snd_buf->len - offset - 1) & 3); 1395 memset(p, 0, pad); 1396 iov->iov_len += pad; 1397 snd_buf->len += pad; 1398 1399 return 0; 1400} 1401 1402static int 1403gss_wrap_req(struct rpc_task *task, 1404 kxdreproc_t encode, void *rqstp, __be32 *p, void *obj) 1405{ 1406 struct rpc_cred *cred = task->tk_rqstp->rq_cred; 1407 struct gss_cred *gss_cred = container_of(cred, struct gss_cred, 1408 gc_base); 1409 struct gss_cl_ctx *ctx = gss_cred_get_ctx(cred); 1410 int status = -EIO; 1411 1412 dprintk("RPC: %5u gss_wrap_req\n", task->tk_pid); 1413 if (ctx->gc_proc != RPC_GSS_PROC_DATA) { 1414 /* The spec seems a little ambiguous here, but I think that not 1415 * wrapping context destruction requests makes the most sense. 1416 */ 1417 gss_wrap_req_encode(encode, rqstp, p, obj); 1418 status = 0; 1419 goto out; 1420 } 1421 switch (gss_cred->gc_service) { 1422 case RPC_GSS_SVC_NONE: 1423 gss_wrap_req_encode(encode, rqstp, p, obj); 1424 status = 0; 1425 break; 1426 case RPC_GSS_SVC_INTEGRITY: 1427 status = gss_wrap_req_integ(cred, ctx, encode, 1428 rqstp, p, obj); 1429 break; 1430 case RPC_GSS_SVC_PRIVACY: 1431 status = gss_wrap_req_priv(cred, ctx, encode, 1432 rqstp, p, obj); 1433 break; 1434 } 1435out: 1436 gss_put_ctx(ctx); 1437 dprintk("RPC: %5u gss_wrap_req returning %d\n", task->tk_pid, status); 1438 return status; 1439} 1440 1441static inline int 1442gss_unwrap_resp_integ(struct rpc_cred *cred, struct gss_cl_ctx *ctx, 1443 struct rpc_rqst *rqstp, __be32 **p) 1444{ 1445 struct xdr_buf *rcv_buf = &rqstp->rq_rcv_buf; 1446 struct xdr_buf integ_buf; 1447 struct xdr_netobj mic; 1448 u32 data_offset, mic_offset; 1449 u32 integ_len; 1450 u32 maj_stat; 1451 int status = -EIO; 1452 1453 integ_len = ntohl(*(*p)++); 1454 if (integ_len & 3) 1455 return status; 1456 data_offset = (u8 *)(*p) - (u8 *)rcv_buf->head[0].iov_base; 1457 mic_offset = integ_len + data_offset; 1458 if (mic_offset > rcv_buf->len) 1459 return status; 1460 if (ntohl(*(*p)++) != rqstp->rq_seqno) 1461 return status; 1462 1463 if (xdr_buf_subsegment(rcv_buf, &integ_buf, data_offset, 1464 mic_offset - data_offset)) 1465 return status; 1466 1467 if (xdr_buf_read_netobj(rcv_buf, &mic, mic_offset)) 1468 return status; 1469 1470 maj_stat = gss_verify_mic(ctx->gc_gss_ctx, &integ_buf, &mic); 1471 if (maj_stat == GSS_S_CONTEXT_EXPIRED) 1472 clear_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags); 1473 if (maj_stat != GSS_S_COMPLETE) 1474 return status; 1475 return 0; 1476} 1477 1478static inline int 1479gss_unwrap_resp_priv(struct rpc_cred *cred, struct gss_cl_ctx *ctx, 1480 struct rpc_rqst *rqstp, __be32 **p) 1481{ 1482 struct xdr_buf *rcv_buf = &rqstp->rq_rcv_buf; 1483 u32 offset; 1484 u32 opaque_len; 1485 u32 maj_stat; 1486 int status = -EIO; 1487 1488 opaque_len = ntohl(*(*p)++); 1489 offset = (u8 *)(*p) - (u8 *)rcv_buf->head[0].iov_base; 1490 if (offset + opaque_len > rcv_buf->len) 1491 return status; 1492 /* remove padding: */ 1493 rcv_buf->len = offset + opaque_len; 1494 1495 maj_stat = gss_unwrap(ctx->gc_gss_ctx, offset, rcv_buf); 1496 if (maj_stat == GSS_S_CONTEXT_EXPIRED) 1497 clear_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags); 1498 if (maj_stat != GSS_S_COMPLETE) 1499 return status; 1500 if (ntohl(*(*p)++) != rqstp->rq_seqno) 1501 return status; 1502 1503 return 0; 1504} 1505 1506 1507static int 1508gss_unwrap_resp(struct rpc_task *task, 1509 kxdrproc_t decode, void *rqstp, __be32 *p, void *obj) 1510{ 1511 struct rpc_cred *cred = task->tk_rqstp->rq_cred; 1512 struct gss_cred *gss_cred = container_of(cred, struct gss_cred, 1513 gc_base); 1514 struct gss_cl_ctx *ctx = gss_cred_get_ctx(cred); 1515 __be32 *savedp = p; 1516 struct kvec *head = ((struct rpc_rqst *)rqstp)->rq_rcv_buf.head; 1517 int savedlen = head->iov_len; 1518 int status = -EIO; 1519 1520 if (ctx->gc_proc != RPC_GSS_PROC_DATA) 1521 goto out_decode; 1522 switch (gss_cred->gc_service) { 1523 case RPC_GSS_SVC_NONE: 1524 break; 1525 case RPC_GSS_SVC_INTEGRITY: 1526 status = gss_unwrap_resp_integ(cred, ctx, rqstp, &p); 1527 if (status) 1528 goto out; 1529 break; 1530 case RPC_GSS_SVC_PRIVACY: 1531 status = gss_unwrap_resp_priv(cred, ctx, rqstp, &p); 1532 if (status) 1533 goto out; 1534 break; 1535 } 1536 /* take into account extra slack for integrity and privacy cases: */ 1537 cred->cr_auth->au_rslack = cred->cr_auth->au_verfsize + (p - savedp) 1538 + (savedlen - head->iov_len); 1539out_decode: 1540 status = decode(rqstp, p, obj); 1541out: 1542 gss_put_ctx(ctx); 1543 dprintk("RPC: %5u gss_unwrap_resp returning %d\n", task->tk_pid, 1544 status); 1545 return status; 1546} 1547 1548static const struct rpc_authops authgss_ops = { 1549 .owner = THIS_MODULE, 1550 .au_flavor = RPC_AUTH_GSS, 1551 .au_name = "RPCSEC_GSS", 1552 .create = gss_create, 1553 .destroy = gss_destroy, 1554 .lookup_cred = gss_lookup_cred, 1555 .crcreate = gss_create_cred 1556}; 1557 1558static const struct rpc_credops gss_credops = { 1559 .cr_name = "AUTH_GSS", 1560 .crdestroy = gss_destroy_cred, 1561 .cr_init = gss_cred_init, 1562 .crbind = rpcauth_generic_bind_cred, 1563 .crmatch = gss_match, 1564 .crmarshal = gss_marshal, 1565 .crrefresh = gss_refresh, 1566 .crvalidate = gss_validate, 1567 .crwrap_req = gss_wrap_req, 1568 .crunwrap_resp = gss_unwrap_resp, 1569}; 1570 1571static const struct rpc_credops gss_nullops = { 1572 .cr_name = "AUTH_GSS", 1573 .crdestroy = gss_destroy_nullcred, 1574 .crbind = rpcauth_generic_bind_cred, 1575 .crmatch = gss_match, 1576 .crmarshal = gss_marshal, 1577 .crrefresh = gss_refresh_null, 1578 .crvalidate = gss_validate, 1579 .crwrap_req = gss_wrap_req, 1580 .crunwrap_resp = gss_unwrap_resp, 1581}; 1582 1583static const struct rpc_pipe_ops gss_upcall_ops_v0 = { 1584 .upcall = gss_pipe_upcall, 1585 .downcall = gss_pipe_downcall, 1586 .destroy_msg = gss_pipe_destroy_msg, 1587 .open_pipe = gss_pipe_open_v0, 1588 .release_pipe = gss_pipe_release, 1589}; 1590 1591static const struct rpc_pipe_ops gss_upcall_ops_v1 = { 1592 .upcall = gss_pipe_upcall, 1593 .downcall = gss_pipe_downcall, 1594 .destroy_msg = gss_pipe_destroy_msg, 1595 .open_pipe = gss_pipe_open_v1, 1596 .release_pipe = gss_pipe_release, 1597}; 1598 1599/* 1600 * Initialize RPCSEC_GSS module 1601 */ 1602static int __init init_rpcsec_gss(void) 1603{ 1604 int err = 0; 1605 1606 err = rpcauth_register(&authgss_ops); 1607 if (err) 1608 goto out; 1609 err = gss_svc_init(); 1610 if (err) 1611 goto out_unregister; 1612 rpc_init_wait_queue(&pipe_version_rpc_waitqueue, "gss pipe version"); 1613 return 0; 1614out_unregister: 1615 rpcauth_unregister(&authgss_ops); 1616out: 1617 return err; 1618} 1619 1620static void __exit exit_rpcsec_gss(void) 1621{ 1622 gss_svc_shutdown(); 1623 rpcauth_unregister(&authgss_ops); 1624 rcu_barrier(); /* Wait for completion of call_rcu()'s */ 1625} 1626 1627MODULE_LICENSE("GPL"); 1628module_param_named(expired_cred_retry_delay, 1629 gss_expired_cred_retry_delay, 1630 uint, 0644); 1631MODULE_PARM_DESC(expired_cred_retry_delay, "Timeout (in seconds) until " 1632 "the RPC engine retries an expired credential"); 1633 1634module_init(init_rpcsec_gss) 1635module_exit(exit_rpcsec_gss) 1636