kern_auth.c revision 1.1.2.17
1 /* $NetBSD: kern_auth.c,v 1.1.2.17 2006/03/11 05:08:42 elad Exp $ */ 2 3 /*- 4 * Copyright (c) 2005, 2006 Elad Efrat <elad (at) NetBSD.org> 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. All advertising materials mentioning features or use of this software 16 * must display the following acknowledgement: 17 * This product includes software developed by Elad Efrat. 18 * 4. The name of the author may not be used to endorse or promote products 19 * derived from this software without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 22 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 23 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 24 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 25 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 26 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 27 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 28 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 29 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 30 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 31 */ 32 33 /* 34 * Todo: 35 * - Garbage collection to pool_put() unused scopes/listeners. 36 */ 37 38 #include <sys/types.h> 39 #include <sys/param.h> 40 #include <sys/queue.h> 41 #include <sys/time.h> 42 #include <sys/proc.h> 43 #include <sys/ucred.h> 44 #include <sys/pool.h> 45 #include <sys/kauth.h> 46 #include <sys/acct.h> 47 48 /* 49 * Credentials. 50 */ 51 struct kauth_cred { 52 struct simplelock cr_lock; /* lock */ 53 uint32_t cr_refcnt; /* reference count */ 54 uid_t cr_uid; /* user id */ 55 uid_t cr_euid; /* effective user id */ 56 uid_t cr_svuid; /* saved effective user id */ 57 gid_t cr_gid; /* group id */ 58 gid_t cr_egid; /* effective group id */ 59 gid_t cr_svgid; /* saved effective group id */ 60 uint16_t cr_ngroups; /* number of groups */ 61 gid_t cr_groups[NGROUPS]; /* group memberships */ 62 }; 63 64 /* 65 * Listener. 66 */ 67 struct kauth_listener { 68 kauth_scope_callback_t func; /* callback */ 69 kauth_scope_t scope; /* scope backpointer */ 70 uint32_t refcnt; /* reference count */ 71 SIMPLEQ_ENTRY(kauth_listener) listener_next; /* listener list */ 72 }; 73 74 /* 75 * Scope. 76 */ 77 struct kauth_scope { 78 const char *id; /* scope name */ 79 void *cookie; /* user cookie */ 80 uint32_t nlisteners; /* # of listeners */ 81 SIMPLEQ_HEAD(, kauth_listener) listenq; /* listener list */ 82 SIMPLEQ_ENTRY(kauth_scope) next_scope; /* scope list */ 83 }; 84 85 POOL_INIT(kauth_scope_pool, sizeof(struct kauth_scope), 0, 0, 0, 86 "kauth_scopepl", &pool_allocator_nointr); 87 POOL_INIT(kauth_listener_pool, sizeof(struct kauth_listener), 0, 0, 0, 88 "kauth_listenerpl", &pool_allocator_nointr); 89 POOL_INIT(kauth_cred_pool, sizeof(struct kauth_cred), 0, 0, 0, 90 "kauth_credpl", &pool_allocator_nointr); 91 92 /* List of scopes and its lock. */ 93 SIMPLEQ_HEAD(, kauth_scope) scope_list; 94 struct simplelock scopes_lock; 95 96 /* Built-in scopes: generic, process. */ 97 static kauth_scope_t kauth_builtin_scope_generic; 98 static kauth_scope_t kauth_builtin_scope_process; 99 100 /* Allocate new, empty kauth credentials. */ 101 kauth_cred_t 102 kauth_cred_alloc(void) { 103 kauth_cred_t cred; 104 105 cred = pool_get(&kauth_cred_pool, PR_WAITOK); 106 memset(cred, 0, sizeof(*cred)); 107 simple_lock_init(&cred->cr_lock); 108 cred->cr_refcnt = 1; 109 110 return (cred); 111 } 112 113 /* Increment reference count to cred. */ 114 void 115 kauth_cred_hold(kauth_cred_t cred) 116 { 117 KASSERT(cred != NULL); 118 119 simple_lock(&cred->cr_lock); 120 cred->cr_refcnt++; 121 simple_unlock(&cred->cr_lock); 122 } 123 124 void 125 kauth_cred_destroy(kauth_cred_t cred) 126 { 127 KASSERT(cred != NULL); 128 129 pool_put(&kauth_cred_pool, cred); 130 } 131 132 /* Decrease reference count to cred. If reached zero, free it. */ 133 void 134 kauth_cred_free(kauth_cred_t cred) { 135 KASSERT(cred != NULL); 136 137 simple_lock(&cred->cr_lock); 138 cred->cr_refcnt--; 139 simple_unlock(&cred->cr_lock); 140 141 if (cred->cr_refcnt == 0) 142 kauth_cred_destroy(cred); 143 } 144 145 void 146 kauth_cred_clone(kauth_cred_t from, kauth_cred_t to) 147 { 148 KASSERT(from != NULL); 149 KASSERT(to != NULL); 150 151 to->cr_uid = from->cr_uid; 152 to->cr_euid = from->cr_euid; 153 to->cr_svuid = from->cr_svuid; 154 to->cr_gid = from->cr_gid; 155 to->cr_egid = from->cr_egid; 156 to->cr_svgid = from->cr_svgid; 157 to->cr_ngroups = from->cr_ngroups; 158 memcpy(to->cr_groups, from->cr_groups, 159 sizeof(to->cr_groups)); 160 } 161 162 /* 163 * Duplicate cred and return a new kauth_cred_t. 164 */ 165 kauth_cred_t 166 kauth_cred_dup(kauth_cred_t cred) 167 { 168 kauth_cred_t new_cred; 169 170 KASSERT(cred != NULL); 171 172 new_cred = kauth_cred_alloc(); 173 174 kauth_cred_clone(cred, new_cred); 175 176 return (new_cred); 177 } 178 179 /* 180 * Similar to crcopy(), only on a kauth_cred_t. 181 * XXX: Is this even needed? [kauth_cred_copy] 182 */ 183 kauth_cred_t 184 kauth_cred_copy(kauth_cred_t cred) 185 { 186 kauth_cred_t new_cred; 187 188 KASSERT(cred != NULL); 189 190 /* If the provided credentials already have one reference, use them. */ 191 if (cred->cr_refcnt == 1) 192 return (cred); 193 194 new_cred = kauth_cred_alloc(); 195 196 kauth_cred_clone(cred, new_cred); 197 198 kauth_cred_free(cred); 199 200 return (new_cred); 201 } 202 203 uid_t 204 kauth_cred_getuid(kauth_cred_t cred) 205 { 206 KASSERT(cred != NULL); 207 208 return (cred->cr_uid); 209 } 210 211 uid_t 212 kauth_cred_geteuid(kauth_cred_t cred) 213 { 214 KASSERT(cred != NULL); 215 216 return (cred->cr_euid); 217 } 218 219 uid_t 220 kauth_cred_getsvuid(kauth_cred_t cred) 221 { 222 KASSERT(cred != NULL); 223 224 return (cred->cr_svuid); 225 } 226 227 gid_t 228 kauth_cred_getgid(kauth_cred_t cred) 229 { 230 KASSERT(cred != NULL); 231 232 return (cred->cr_gid); 233 } 234 235 gid_t 236 kauth_cred_getegid(kauth_cred_t cred) 237 { 238 KASSERT(cred != NULL); 239 240 return (cred->cr_egid); 241 } 242 243 gid_t 244 kauth_cred_getsvgid(kauth_cred_t cred) 245 { 246 KASSERT(cred != NULL); 247 248 return (cred->cr_svgid); 249 } 250 251 void 252 kauth_cred_setuid(kauth_cred_t cred, uid_t uid) 253 { 254 KASSERT(cred != NULL); 255 KASSERT(uid >= 0 && uid <= UID_MAX); 256 257 cred->cr_uid = uid; 258 } 259 260 void 261 kauth_cred_seteuid(kauth_cred_t cred, uid_t uid) 262 { 263 KASSERT(cred != NULL); 264 KASSERT(uid >= 0 && uid <= UID_MAX); 265 266 cred->cr_euid = uid; 267 } 268 269 void 270 kauth_cred_setsvuid(kauth_cred_t cred, uid_t uid) 271 { 272 KASSERT(cred != NULL); 273 KASSERT(uid >= 0 && uid <= UID_MAX); 274 275 cred->cr_svuid = uid; 276 } 277 278 void 279 kauth_cred_setgid(kauth_cred_t cred, gid_t gid) 280 { 281 KASSERT(cred != NULL); 282 KASSERT(gid >= 0 && gid <= GID_MAX); 283 284 cred->cr_gid = gid; 285 } 286 287 void 288 kauth_cred_setegid(kauth_cred_t cred, gid_t gid) 289 { 290 KASSERT(cred != NULL); 291 KASSERT(gid >= 0 && gid <= GID_MAX); 292 293 cred->cr_egid = gid; 294 } 295 296 void 297 kauth_cred_setsvgid(kauth_cred_t cred, gid_t gid) 298 { 299 KASSERT(cred != NULL); 300 KASSERT(gid >= 0 && gid <= GID_MAX); 301 302 cred->cr_svgid = gid; 303 } 304 305 /* Checks if gid is a member of the groups in cred. */ 306 int 307 kauth_cred_ismember_gid(kauth_cred_t cred, gid_t gid, int *resultp) 308 { 309 int i; 310 311 KASSERT(cred != NULL); 312 KASSERT(gid >= 0 && gid <= GID_MAX); 313 KASSERT(resultp != NULL); 314 315 *resultp = 0; 316 317 for (i = 0; i < cred->cr_ngroups; i++) { 318 if (cred->cr_groups[i] == gid) 319 *resultp = 1; 320 } 321 322 return (0); 323 } 324 325 uint16_t 326 kauth_cred_ngroups(kauth_cred_t cred) 327 { 328 KASSERT(cred != NULL); 329 330 return (cred->cr_ngroups); 331 } 332 333 /* 334 * Return the group at index idx from the groups in cred. 335 */ 336 gid_t 337 kauth_cred_group(kauth_cred_t cred, uint16_t idx) 338 { 339 KASSERT(cred != NULL); 340 KASSERT(idx < cred->cr_ngroups); 341 342 return (cred->cr_groups[idx]); 343 } 344 345 /* Sort len groups in grbuf. */ 346 static void 347 kauth_cred_sortgroups(gid_t *grbuf, size_t len) 348 { 349 int i, j; 350 gid_t v; 351 352 KASSERT(grbuf != NULL); 353 354 /* Insertion sort. */ 355 for (i = 1; i < len; i++) { 356 v = grbuf[i]; 357 /* find correct slot for value v, moving others up */ 358 for (j = i; --j >= 0 && v < grbuf[j];) 359 grbuf[j + 1] = grbuf[j]; 360 grbuf[j + 1] = v; 361 } 362 } 363 364 /* Add group gid to groups in cred. Maintain order. */ 365 int 366 kauth_cred_addgroup(kauth_cred_t cred, gid_t gid) 367 { 368 int error, ismember; 369 370 KASSERT(cred != NULL); 371 KASSERT(gid >= 0 && gid <= GID_MAX); 372 373 simple_lock(&cred->cr_lock); 374 375 if (cred->cr_ngroups >= 376 (sizeof(cred->cr_groups) / sizeof(cred->cr_groups[0]))) { 377 simple_unlock(&cred->cr_lock); 378 return (E2BIG); 379 } 380 381 error = kauth_cred_ismember_gid(cred, gid, &ismember); 382 if (error) { 383 simple_unlock(&cred->cr_lock); 384 return (error); 385 } 386 387 if (ismember) { 388 simple_unlock(&cred->cr_lock); 389 return (0); 390 } 391 392 cred->cr_groups[cred->cr_ngroups++] = gid; 393 394 kauth_cred_sortgroups(cred->cr_groups, cred->cr_ngroups); 395 396 simple_unlock(&cred->cr_lock); 397 398 return (0); 399 } 400 401 /* Delete group gid from groups in cred. Maintain order. */ 402 int 403 kauth_cred_delgroup(kauth_cred_t cred, gid_t gid) 404 { 405 int error, ismember; 406 407 KASSERT(cred != NULL); 408 KASSERT(gid >= 0 && gid <= GID_MAX); 409 410 simple_lock(&cred->cr_lock); 411 412 error = kauth_cred_ismember_gid(cred, gid, &ismember); 413 if (error) { 414 simple_unlock(&cred->cr_lock); 415 return (error); 416 } 417 418 if (!ismember) { 419 simple_unlock(&cred->cr_lock); 420 return (0); 421 } 422 423 if (cred->cr_ngroups == 1) 424 cred->cr_groups[0] = (gid_t)-1; /* XXX */ 425 else { 426 int i; 427 428 for (i = 0; i < cred->cr_ngroups; i++) 429 if (cred->cr_groups[i] == gid) { 430 cred->cr_groups[i] = cred->cr_groups[cred->cr_ngroups - 1]; 431 cred->cr_groups[cred->cr_ngroups - 1] = (gid_t)-1; /* XXX */ 432 } 433 } 434 435 cred->cr_ngroups--; 436 437 kauth_cred_sortgroups(cred->cr_groups, cred->cr_ngroups); 438 439 simple_unlock(&cred->cr_lock); 440 441 return (0); 442 } 443 444 /* 445 * Match uids in two credentials. Checks if cred1 can access stuff owned by 446 * cred2. 447 * XXX: root bypasses this! 448 */ 449 int 450 kauth_cred_uidmatch(kauth_cred_t cred1, kauth_cred_t cred2) 451 { 452 KASSERT(cred1 != NULL); 453 KASSERT(cred2 != NULL); 454 455 /* Are we root? */ 456 if (cred1->cr_euid == 0) 457 return (1); 458 459 if (cred1->cr_uid == cred2->cr_uid || 460 cred1->cr_euid == cred2->cr_uid || 461 cred1->cr_uid == cred2->cr_euid || 462 cred1->cr_euid == cred2->cr_euid) 463 return (1); 464 465 return (0); 466 } 467 468 uint32_t 469 kauth_cred_getrefcnt(kauth_cred_t cred) 470 { 471 KASSERT(cred != NULL); 472 473 return (cred->cr_refcnt); 474 } 475 476 /* XXX: memcmp() wrapper needed for NFSW_SAMECRED() in nfs/nfs.h */ 477 int 478 kauth_cred_memcmp(kauth_cred_t cred1, kauth_cred_t cred2) 479 { 480 KASSERT(cred1 != NULL); 481 KASSERT(cred2 != NULL); 482 483 return (memcmp(cred1, cred2, sizeof(*cred1))); 484 } 485 486 /* 487 * Convert userland credentials (struct uucred) to kauth_cred_t. 488 * XXX: For NFS code. 489 */ 490 void 491 kauth_cred_convert(kauth_cred_t cred, const struct uucred *uuc) 492 { 493 int i; 494 495 KASSERT(cred != NULL); 496 KASSERT(uuc != NULL); 497 498 cred->cr_refcnt = 1; 499 cred->cr_euid = uuc->cr_uid; 500 cred->cr_egid = uuc->cr_gid; 501 cred->cr_ngroups = min(uuc->cr_ngroups, NGROUPS); 502 for (i = 0; i < cred->cr_ngroups; i++) 503 kauth_cred_addgroup(cred, uuc->cr_groups[i]); 504 } 505 506 /* 507 * Compare kauth_cred_t and uucred credentials. 508 * XXX: Modelled after crcmp() for NFS. 509 */ 510 int 511 kauth_cred_compare(kauth_cred_t cred, const struct uucred *uuc) 512 { 513 KASSERT(cred != NULL); 514 KASSERT(uuc != NULL); 515 516 if (cred->cr_euid == uuc->cr_uid && 517 cred->cr_egid == uuc->cr_gid && 518 cred->cr_ngroups == uuc->cr_ngroups) { 519 /* Check if all groups from uuc appear in cred. */ 520 for (i = 0; i < uuc->cr_ngroups; i++) { 521 int i, error, ismember; 522 523 error = kauth_cred_ismember_gid(cred, 524 uuc->cr_ngroups[i], &ismember); 525 if (error || !ismember) 526 return (0); 527 } 528 529 return (1); 530 } 531 532 return (0); 533 } 534 535 /* 536 * Make a struct ucred out of a kauth_cred_t. 537 * XXX: For sysctl. 538 */ 539 void 540 kauth_cred_toucred(kauth_cred_t cred, struct ucred *uc) 541 { 542 KASSERT(cred != NULL); 543 KASSERT(uc != NULL); 544 545 uc->cr_uid = cred->cr_euid; 546 uc->cr_gid = cred->cr_egid; 547 uc->cr_ngroups = min(cred->cr_ngroups, 548 sizeof(uc->cr_groups) / sizeof(uc->cr_groups[0])); 549 memcpy(uc->cr_groups, cred->cr_groups, 550 uc->cr_ngroups * sizeof(uc->cr_groups[0])); 551 } 552 553 /* 554 * Make a struct pcred out of a kauth_cred_t. 555 * XXX: For sysctl. 556 */ 557 void 558 kauth_cred_topcred(kauth_cred_t cred, struct pcred *pc) 559 { 560 KASSERT(cred != NULL); 561 KASSERT(pc != NULL); 562 563 pc->pc_ucred = (struct ucred *)cred; /* XXX this is just wrong */ 564 pc->p_ruid = cred->cr_uid; 565 pc->p_svuid = cred->cr_svuid; 566 pc->p_rgid = cred->cr_gid; 567 pc->p_svgid = cred->cr_svgid; 568 pc->p_refcnt = cred->cr_refcnt; 569 } 570 571 /* 572 * Return kauth_cred_t for the current process. 573 */ 574 kauth_cred_t 575 kauth_cred_get(void) 576 { 577 return (curproc->p_cred); 578 } 579 580 /* 581 * Returns a scope matching the provided id. 582 * Requires the scope list lock to be held by the caller. 583 */ 584 static kauth_scope_t 585 kauth_ifindscope(const char *id) { 586 kauth_scope_t scope; 587 588 /* XXX: assert lock on scope list? */ 589 590 scope = NULL; 591 SIMPLEQ_FOREACH(scope, &scope_list, next_scope) { 592 if (strcmp(scope->id, id) == 0) 593 break; 594 } 595 596 return (scope); 597 } 598 599 /* 600 * Register a new scope. 601 * 602 * id - identifier for the scope 603 * callback - the scope's default listener 604 * cookie - cookie to be passed to the listener(s) 605 */ 606 kauth_scope_t 607 kauth_register_scope(const char *id, kauth_scope_callback_t callback, 608 void *cookie) 609 { 610 kauth_scope_t scope; 611 kauth_listener_t listener; 612 613 /* Sanitize input */ 614 if (id == NULL || callback == NULL) 615 return (NULL); 616 617 /* Allocate space for a new scope and listener. */ 618 scope = pool_get(&kauth_scope_pool, PR_WAITOK); 619 listener = pool_get(&kauth_listener_pool, PR_WAITOK); 620 621 /* Acquire scope list lock. */ 622 simple_lock(&scopes_lock); 623 624 /* Check we don't already have a scope with the same id */ 625 if (kauth_ifindscope(id) != NULL) { 626 simple_unlock(&scopes_lock); 627 628 pool_put(&kauth_scope_pool, scope); 629 pool_put(&kauth_listener_pool, listener); 630 631 return (NULL); 632 } 633 634 /* Initialize new scope with parameters */ 635 scope->id = id; 636 scope->cookie = cookie; 637 scope->nlisteners = 1; 638 639 /* Add default listener */ 640 listener->func = callback; 641 listener->scope = scope; 642 listener->refcnt = 0; 643 SIMPLEQ_INIT(&scope->listenq); 644 SIMPLEQ_INSERT_HEAD(&scope->listenq, listener, listener_next); 645 646 /* Insert scope to scopes list */ 647 if (SIMPLEQ_EMPTY(&scope_list)) 648 SIMPLEQ_INSERT_HEAD(&scope_list, scope, next_scope); 649 else 650 SIMPLEQ_INSERT_TAIL(&scope_list, scope, next_scope); 651 652 simple_unlock(&scopes_lock); 653 654 return (scope); 655 } 656 657 /* 658 * Initialize the kernel authorization subsystem. 659 * 660 * Initialize the scopes list lock. 661 * Register built-in scopes: generic, process. 662 */ 663 void 664 kauth_init(void) 665 { 666 simple_lock_init(&scopes_lock); 667 668 /* Register generic scope. */ 669 kauth_builtin_scope_generic = kauth_register_scope(KAUTH_SCOPE_GENERIC, 670 kauth_authorize_cb_generic, NULL); 671 672 /* Register process scope. */ 673 kauth_builtin_scope_process = kauth_register_scope(KAUTH_SCOPE_PROCESS, 674 kauth_authorize_cb_process, NULL); 675 } 676 677 /* 678 * Deregister a scope. 679 * Requires scope list lock to be held by the caller. 680 * 681 * scope - the scope to deregister 682 */ 683 void 684 kauth_deregister_scope(kauth_scope_t scope) 685 { 686 if (scope != NULL) { 687 /* Remove scope from list */ 688 SIMPLEQ_REMOVE(&scope_list, scope, kauth_scope, next_scope); 689 } 690 } 691 692 /* 693 * Register a listener. 694 * 695 * id - scope identifier. 696 * callback - the callback routine for the listener. 697 * cookie - cookie to pass unmoidfied to the callback. 698 */ 699 kauth_listener_t 700 kauth_listen_scope(const char *id, kauth_scope_callback_t callback, 701 void *cookie) 702 { 703 kauth_scope_t scope; 704 kauth_listener_t listener; 705 706 /* Find scope struct */ 707 simple_lock(&scopes_lock); 708 scope = kauth_ifindscope(id); 709 simple_unlock(&scopes_lock); 710 if (scope == NULL) 711 return (NULL); 712 713 /* Allocate listener */ 714 listener = pool_get(&kauth_listener_pool, PR_WAITOK); 715 716 /* Initialize listener with parameters */ 717 listener->func = callback; 718 listener->refcnt = 0; 719 720 /* Add listener to scope */ 721 SIMPLEQ_INSERT_TAIL(&scope->listenq, listener, listener_next); 722 723 /* Raise number of listeners on scope. */ 724 scope->nlisteners++; 725 listener->scope = scope; 726 727 return (listener); 728 } 729 730 /* 731 * Deregister a listener. 732 * 733 * listener - listener reference as returned from kauth_listen_scope(). 734 */ 735 void 736 kauth_unlisten_scope(kauth_listener_t listener) 737 { 738 if (listener != NULL) { 739 SIMPLEQ_REMOVE(&listener->scope->listenq, listener, kauth_listener, 740 listener_next); 741 listener->scope->nlisteners--; 742 } 743 } 744 745 /* 746 * Authorize a request. 747 * 748 * scope - the scope of the request as defined by KAUTH_SCOPE_* or as 749 * returned from kauth_register_scope(). 750 * credential - credentials of the user ("actor") making the request. 751 * action - request identifier. 752 * arg[0-3] - passed unmodified to listener(s). 753 */ 754 int 755 kauth_authorize_action(kauth_scope_t scope, kauth_cred_t cred, 756 kauth_action_t action, void *arg0, void *arg1, 757 void *arg2, void *arg3) 758 { 759 kauth_listener_t listener; 760 int error, allow, fail; 761 762 /* Sanitize input */ 763 if (scope == NULL || cred == NULL) 764 return (EFAULT); 765 if (!action) 766 return (EINVAL); 767 768 /* 769 * Each scope is associated with at least one listener. We need to 770 * traverse that list of listeners, as long as they return either 771 * KAUTH_REQUEST_DEFER or KAUTH_REQUEST_ALLOW. 772 */ 773 fail = 0; 774 allow = 0; 775 SIMPLEQ_FOREACH(listener, &scope->listenq, listener_next) { 776 error = listener->func(cred, action, scope->cookie, arg0, 777 arg1, arg2, arg3); 778 779 if (error == KAUTH_RESULT_ALLOW) 780 allow = 1; 781 else if (error == KAUTH_RESULT_DENY) 782 fail = 1; 783 } 784 785 return ((allow && !fail) ? 0 : EPERM); 786 }; 787 788 /* 789 * Generic scope default callback. 790 */ 791 int 792 kauth_authorize_cb_generic(kauth_cred_t cred, kauth_action_t action, 793 void *cookie, void *arg0, void *arg1, void *arg2, 794 void *arg3) 795 { 796 int error; 797 798 error = KAUTH_RESULT_DEFER; 799 800 switch (action) { 801 case KAUTH_GENERIC_ISSUSER: 802 /* Check if credential belongs to superuser. */ 803 if (cred->cr_euid == 0) { 804 u_short *acflag = (u_short *)arg0; 805 806 if (acflag != NULL) 807 *acflag |= ASU; 808 809 error = KAUTH_RESULT_ALLOW; 810 } else 811 error = KAUTH_RESULT_DENY; 812 break; 813 } 814 815 return (error); 816 } 817 818 /* 819 * Generic scope authorization wrapper. 820 */ 821 int 822 kauth_authorize_generic(kauth_cred_t cred, kauth_action_t action, void *arg0) 823 { 824 return (kauth_authorize_action(kauth_builtin_scope_generic, cred, 825 action, arg0, NULL, NULL, NULL)); 826 } 827 828 /* 829 * Process scope default callback. 830 */ 831 int 832 kauth_authorize_cb_process(kauth_cred_t cred, kauth_action_t action, 833 void *cookie, void *arg0, void *arg1, void *arg2, 834 void *arg3) 835 { 836 struct proc *p; 837 kauth_cred_t cred2; 838 int error; 839 840 error = KAUTH_RESULT_DEFER; 841 842 p = arg0; 843 cred2 = arg1; 844 845 switch (action) { 846 case KAUTH_PROCESS_CANSIGNAL: { 847 struct proc *to; 848 int signum; 849 850 to = arg2; 851 signum = (int)(unsigned long)arg3; 852 853 if (kauth_cred_uidmatch(cred, cred2) || 854 (signum == SIGCONT && (p->p_session == to->p_session))) 855 error = KAUTH_RESULT_ALLOW; 856 else 857 error = KAUTH_RESULT_DEFER; 858 859 break; 860 } 861 862 case KAUTH_PROCESS_CANPTRACE: 863 if (kauth_cred_uidmatch(cred, cred2)) 864 error = KAUTH_RESULT_ALLOW; 865 else 866 error = KAUTH_RESULT_DENY; 867 break; 868 869 case KAUTH_PROCESS_CANSEE: 870 if (kauth_cred_uidmatch(cred, cred2)) 871 error = KAUTH_RESULT_ALLOW; 872 else 873 error = KAUTH_RESULT_DENY; 874 /* arg2 - type of information [XXX NOTIMPL] */ 875 break; 876 } 877 878 return (error); 879 } 880 881 /* 882 * Process scope authorization wrapper. 883 */ 884 int 885 kauth_authorize_process(kauth_cred_t cred, kauth_action_t action, 886 struct proc *p, void *arg1, void *arg2, void *arg3) 887 { 888 return (kauth_authorize_action(kauth_builtin_scope_process, cred, 889 action, p, arg1, arg2, arg3)); 890 } 891
Indexes created Mon Sep 22 13:09:51 GMT 2025