sys/kern/kern_prot.c

   1 /*-
   2  * Copyright (c) 1982, 1986, 1989, 1990, 1991, 1993
   3  *      The Regents of the University of California.
   4  * (c) UNIX System Laboratories, Inc.
   5  * Copyright (c) 2000-2001 Robert N. M. Watson.
   6  * All rights reserved.
   7  *
   8  * All or some portions of this file are derived from material licensed
   9  * to the University of California by American Telephone and Telegraph
  10  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
  11  * the permission of UNIX System Laboratories, Inc.
  12  *
  13  * Redistribution and use in source and binary forms, with or without
  14  * modification, are permitted provided that the following conditions
  15  * are met:
  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 contributors
  22  *    may be used to endorse or promote products derived from this software
  23  *    without specific prior written permission.
  24  *
  25  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  26  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  27  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  28  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  29  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  30  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  31  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  32  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  33  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  34  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  35  * SUCH DAMAGE.
  36  *
  37  *      @(#)kern_prot.c 8.6 (Berkeley) 1/21/94
  38  */
  39
  40 /*
  41  * System calls related to processes and protection
  42  */
  43
  44 #include <sys/cdefs.h>
  45 __FBSDID("$FreeBSD$");
  46
  47 #include "opt_compat.h"
  48 #include "opt_inet.h"
  49 #include "opt_inet6.h"
  50
  51 #include <sys/param.h>
  52 #include <sys/systm.h>
  53 #include <sys/acct.h>
  54 #include <sys/kdb.h>
  55 #include <sys/kernel.h>
  56 #include <sys/lock.h>
  57 #include <sys/loginclass.h>
  58 #include <sys/malloc.h>
  59 #include <sys/mutex.h>
  60 #include <sys/refcount.h>
  61 #include <sys/sx.h>
  62 #include <sys/priv.h>
  63 #include <sys/proc.h>
  64 #include <sys/sysproto.h>
  65 #include <sys/jail.h>
  66 #include <sys/pioctl.h>
  67 #include <sys/racct.h>
  68 #include <sys/resourcevar.h>
  69 #include <sys/socket.h>
  70 #include <sys/socketvar.h>
  71 #include <sys/syscallsubr.h>
  72 #include <sys/sysctl.h>
  73
  74 #ifdef REGRESSION
  75 FEATURE(regression,
  76     "Kernel support for interfaces necessary for regression testing (SECURITY RISK!)");
  77 #endif
  78
  79 #include <security/audit/audit.h>
  80 #include <security/mac/mac_framework.h>
  81
  82 static MALLOC_DEFINE(M_CRED, "cred", "credentials");
  83
  84 SYSCTL_NODE(_security, OID_AUTO, bsd, CTLFLAG_RW, 0, "BSD security policy");
  85
  86 static void crsetgroups_locked(struct ucred *cr, int ngrp,
  87     gid_t *groups);
  88
  89 #ifndef _SYS_SYSPROTO_H_
  90 struct getpid_args {
  91         int     dummy;
  92 };
  93 #endif
  94 /* ARGSUSED */
  95 int
  96 sys_getpid(struct thread *td, struct getpid_args *uap)
  97 {
  98         struct proc *p = td->td_proc;
  99
 100         td->td_retval[0] = p->p_pid;
 101 #if defined(COMPAT_43)
 102         td->td_retval[1] = kern_getppid(td);
 103 #endif
 104         return (0);
 105 }
 106
 107 #ifndef _SYS_SYSPROTO_H_
 108 struct getppid_args {
 109         int     dummy;
 110 };
 111 #endif
 112 /* ARGSUSED */
 113 int
 114 sys_getppid(struct thread *td, struct getppid_args *uap)
 115 {
 116
 117         td->td_retval[0] = kern_getppid(td);
 118         return (0);
 119 }
 120
 121 int
 122 kern_getppid(struct thread *td)
 123 {
 124         struct proc *p = td->td_proc;
 125         struct proc *pp;
 126         int ppid;
 127
 128         PROC_LOCK(p);
 129         if (!(p->p_flag & P_TRACED)) {
 130                 ppid = p->p_pptr->p_pid;
 131                 PROC_UNLOCK(p);
 132         } else {
 133                 PROC_UNLOCK(p);
 134                 sx_slock(&proctree_lock);
 135                 pp = proc_realparent(p);
 136                 ppid = pp->p_pid;
 137                 sx_sunlock(&proctree_lock);
 138         }
 139
 140         return (ppid);
 141 }
 142
 143 /*
 144  * Get process group ID; note that POSIX getpgrp takes no parameter.
 145  */
 146 #ifndef _SYS_SYSPROTO_H_
 147 struct getpgrp_args {
 148         int     dummy;
 149 };
 150 #endif
 151 int
 152 sys_getpgrp(struct thread *td, struct getpgrp_args *uap)
 153 {
 154         struct proc *p = td->td_proc;
 155
 156         PROC_LOCK(p);
 157         td->td_retval[0] = p->p_pgrp->pg_id;
 158         PROC_UNLOCK(p);
 159         return (0);
 160 }
 161
 162 /* Get an arbitrary pid's process group id */
 163 #ifndef _SYS_SYSPROTO_H_
 164 struct getpgid_args {
 165         pid_t   pid;
 166 };
 167 #endif
 168 int
 169 sys_getpgid(struct thread *td, struct getpgid_args *uap)
 170 {
 171         struct proc *p;
 172         int error;
 173
 174         if (uap->pid == 0) {
 175                 p = td->td_proc;
 176                 PROC_LOCK(p);
 177         } else {
 178                 p = pfind(uap->pid);
 179                 if (p == NULL)
 180                         return (ESRCH);
 181                 error = p_cansee(td, p);
 182                 if (error) {
 183                         PROC_UNLOCK(p);
 184                         return (error);
 185                 }
 186         }
 187         td->td_retval[0] = p->p_pgrp->pg_id;
 188         PROC_UNLOCK(p);
 189         return (0);
 190 }
 191
 192 /*
 193  * Get an arbitrary pid's session id.
 194  */
 195 #ifndef _SYS_SYSPROTO_H_
 196 struct getsid_args {
 197         pid_t   pid;
 198 };
 199 #endif
 200 int
 201 sys_getsid(struct thread *td, struct getsid_args *uap)
 202 {
 203         struct proc *p;
 204         int error;
 205
 206         if (uap->pid == 0) {
 207                 p = td->td_proc;
 208                 PROC_LOCK(p);
 209         } else {
 210                 p = pfind(uap->pid);
 211                 if (p == NULL)
 212                         return (ESRCH);
 213                 error = p_cansee(td, p);
 214                 if (error) {
 215                         PROC_UNLOCK(p);
 216                         return (error);
 217                 }
 218         }
 219         td->td_retval[0] = p->p_session->s_sid;
 220         PROC_UNLOCK(p);
 221         return (0);
 222 }
 223
 224 #ifndef _SYS_SYSPROTO_H_
 225 struct getuid_args {
 226         int     dummy;
 227 };
 228 #endif
 229 /* ARGSUSED */
 230 int
 231 sys_getuid(struct thread *td, struct getuid_args *uap)
 232 {
 233
 234         td->td_retval[0] = td->td_ucred->cr_ruid;
 235 #if defined(COMPAT_43)
 236         td->td_retval[1] = td->td_ucred->cr_uid;
 237 #endif
 238         return (0);
 239 }
 240
 241 #ifndef _SYS_SYSPROTO_H_
 242 struct geteuid_args {
 243         int     dummy;
 244 };
 245 #endif
 246 /* ARGSUSED */
 247 int
 248 sys_geteuid(struct thread *td, struct geteuid_args *uap)
 249 {
 250
 251         td->td_retval[0] = td->td_ucred->cr_uid;
 252         return (0);
 253 }
 254
 255 #ifndef _SYS_SYSPROTO_H_
 256 struct getgid_args {
 257         int     dummy;
 258 };
 259 #endif
 260 /* ARGSUSED */
 261 int
 262 sys_getgid(struct thread *td, struct getgid_args *uap)
 263 {
 264
 265         td->td_retval[0] = td->td_ucred->cr_rgid;
 266 #if defined(COMPAT_43)
 267         td->td_retval[1] = td->td_ucred->cr_groups[0];
 268 #endif
 269         return (0);
 270 }
 271
 272 /*
 273  * Get effective group ID.  The "egid" is groups[0], and could be obtained
 274  * via getgroups.  This syscall exists because it is somewhat painful to do
 275  * correctly in a library function.
 276  */
 277 #ifndef _SYS_SYSPROTO_H_
 278 struct getegid_args {
 279         int     dummy;
 280 };
 281 #endif
 282 /* ARGSUSED */
 283 int
 284 sys_getegid(struct thread *td, struct getegid_args *uap)
 285 {
 286
 287         td->td_retval[0] = td->td_ucred->cr_groups[0];
 288         return (0);
 289 }
 290
 291 #ifndef _SYS_SYSPROTO_H_
 292 struct getgroups_args {
 293         u_int   gidsetsize;
 294         gid_t   *gidset;
 295 };
 296 #endif
 297 int
 298 sys_getgroups(struct thread *td, register struct getgroups_args *uap)
 299 {
 300         struct ucred *cred;
 301         u_int ngrp;
 302         int error;
 303
 304         cred = td->td_ucred;
 305         ngrp = cred->cr_ngroups;
 306
 307         if (uap->gidsetsize == 0) {
 308                 error = 0;
 309                 goto out;
 310         }
 311         if (uap->gidsetsize < ngrp)
 312                 return (EINVAL);
 313
 314         error = copyout(cred->cr_groups, uap->gidset, ngrp * sizeof(gid_t));
 315 out:
 316         td->td_retval[0] = ngrp;
 317         return (error);
 318 }
 319
 320 #ifndef _SYS_SYSPROTO_H_
 321 struct setsid_args {
 322         int     dummy;
 323 };
 324 #endif
 325 /* ARGSUSED */
 326 int
 327 sys_setsid(register struct thread *td, struct setsid_args *uap)
 328 {
 329         struct pgrp *pgrp;
 330         int error;
 331         struct proc *p = td->td_proc;
 332         struct pgrp *newpgrp;
 333         struct session *newsess;
 334
 335         error = 0;
 336         pgrp = NULL;
 337
 338         newpgrp = malloc(sizeof(struct pgrp), M_PGRP, M_WAITOK | M_ZERO);
 339         newsess = malloc(sizeof(struct session), M_SESSION, M_WAITOK | M_ZERO);
 340
 341         sx_xlock(&proctree_lock);
 342
 343         if (p->p_pgid == p->p_pid || (pgrp = pgfind(p->p_pid)) != NULL) {
 344                 if (pgrp != NULL)
 345                         PGRP_UNLOCK(pgrp);
 346                 error = EPERM;
 347         } else {
 348                 (void)enterpgrp(p, p->p_pid, newpgrp, newsess);
 349                 td->td_retval[0] = p->p_pid;
 350                 newpgrp = NULL;
 351                 newsess = NULL;
 352         }
 353
 354         sx_xunlock(&proctree_lock);
 355
 356         if (newpgrp != NULL)
 357                 free(newpgrp, M_PGRP);
 358         if (newsess != NULL)
 359                 free(newsess, M_SESSION);
 360
 361         return (error);
 362 }
 363
 364 /*
 365  * set process group (setpgid/old setpgrp)
 366  *
 367  * caller does setpgid(targpid, targpgid)
 368  *
 369  * pid must be caller or child of caller (ESRCH)
 370  * if a child
 371  *      pid must be in same session (EPERM)
 372  *      pid can't have done an exec (EACCES)
 373  * if pgid != pid
 374  *      there must exist some pid in same session having pgid (EPERM)
 375  * pid must not be session leader (EPERM)
 376  */
 377 #ifndef _SYS_SYSPROTO_H_
 378 struct setpgid_args {
 379         int     pid;            /* target process id */
 380         int     pgid;           /* target pgrp id */
 381 };
 382 #endif
 383 /* ARGSUSED */
 384 int
 385 sys_setpgid(struct thread *td, register struct setpgid_args *uap)
 386 {
 387         struct proc *curp = td->td_proc;
 388         register struct proc *targp;    /* target process */
 389         register struct pgrp *pgrp;     /* target pgrp */
 390         int error;
 391         struct pgrp *newpgrp;
 392
 393         if (uap->pgid < 0)
 394                 return (EINVAL);
 395
 396         error = 0;
 397
 398         newpgrp = malloc(sizeof(struct pgrp), M_PGRP, M_WAITOK | M_ZERO);
 399
 400         sx_xlock(&proctree_lock);
 401         if (uap->pid != 0 && uap->pid != curp->p_pid) {
 402                 if ((targp = pfind(uap->pid)) == NULL) {
 403                         error = ESRCH;
 404                         goto done;
 405                 }
 406                 if (!inferior(targp)) {
 407                         PROC_UNLOCK(targp);
 408                         error = ESRCH;
 409                         goto done;
 410                 }
 411                 if ((error = p_cansee(td, targp))) {
 412                         PROC_UNLOCK(targp);
 413                         goto done;
 414                 }
 415                 if (targp->p_pgrp == NULL ||
 416                     targp->p_session != curp->p_session) {
 417                         PROC_UNLOCK(targp);
 418                         error = EPERM;
 419                         goto done;
 420                 }
 421                 if (targp->p_flag & P_EXEC) {
 422                         PROC_UNLOCK(targp);
 423                         error = EACCES;
 424                         goto done;
 425                 }
 426                 PROC_UNLOCK(targp);
 427         } else
 428                 targp = curp;
 429         if (SESS_LEADER(targp)) {
 430                 error = EPERM;
 431                 goto done;
 432         }
 433         if (uap->pgid == 0)
 434                 uap->pgid = targp->p_pid;
 435         if ((pgrp = pgfind(uap->pgid)) == NULL) {
 436                 if (uap->pgid == targp->p_pid) {
 437                         error = enterpgrp(targp, uap->pgid, newpgrp,
 438                             NULL);
 439                         if (error == 0)
 440                                 newpgrp = NULL;
 441                 } else
 442                         error = EPERM;
 443         } else {
 444                 if (pgrp == targp->p_pgrp) {
 445                         PGRP_UNLOCK(pgrp);
 446                         goto done;
 447                 }
 448                 if (pgrp->pg_id != targp->p_pid &&
 449                     pgrp->pg_session != curp->p_session) {
 450                         PGRP_UNLOCK(pgrp);
 451                         error = EPERM;
 452                         goto done;
 453                 }
 454                 PGRP_UNLOCK(pgrp);
 455                 error = enterthispgrp(targp, pgrp);
 456         }
 457 done:
 458         sx_xunlock(&proctree_lock);
 459         KASSERT((error == 0) || (newpgrp != NULL),
 460             ("setpgid failed and newpgrp is NULL"));
 461         if (newpgrp != NULL)
 462                 free(newpgrp, M_PGRP);
 463         return (error);
 464 }
 465
 466 /*
 467  * Use the clause in B.4.2.2 that allows setuid/setgid to be 4.2/4.3BSD
 468  * compatible.  It says that setting the uid/gid to euid/egid is a special
 469  * case of "appropriate privilege".  Once the rules are expanded out, this
 470  * basically means that setuid(nnn) sets all three id's, in all permitted
 471  * cases unless _POSIX_SAVED_IDS is enabled.  In that case, setuid(getuid())
 472  * does not set the saved id - this is dangerous for traditional BSD
 473  * programs.  For this reason, we *really* do not want to set
 474  * _POSIX_SAVED_IDS and do not want to clear POSIX_APPENDIX_B_4_2_2.
 475  */
 476 #define POSIX_APPENDIX_B_4_2_2
 477
 478 #ifndef _SYS_SYSPROTO_H_
 479 struct setuid_args {
 480         uid_t   uid;
 481 };
 482 #endif
 483 /* ARGSUSED */
 484 int
 485 sys_setuid(struct thread *td, struct setuid_args *uap)
 486 {
 487         struct proc *p = td->td_proc;
 488         struct ucred *newcred, *oldcred;
 489         uid_t uid;
 490         struct uidinfo *uip;
 491         int error;
 492
 493         uid = uap->uid;
 494         AUDIT_ARG_UID(uid);
 495         newcred = crget();
 496         uip = uifind(uid);
 497         PROC_LOCK(p);
 498         /*
 499          * Copy credentials so other references do not see our changes.
 500          */
 501         oldcred = crcopysafe(p, newcred);
 502
 503 #ifdef MAC
 504         error = mac_cred_check_setuid(oldcred, uid);
 505         if (error)
 506                 goto fail;
 507 #endif
 508
 509         /*
 510          * See if we have "permission" by POSIX 1003.1 rules.
 511          *
 512          * Note that setuid(geteuid()) is a special case of
 513          * "appropriate privileges" in appendix B.4.2.2.  We need
 514          * to use this clause to be compatible with traditional BSD
 515          * semantics.  Basically, it means that "setuid(xx)" sets all
 516          * three id's (assuming you have privs).
 517          *
 518          * Notes on the logic.  We do things in three steps.
 519          * 1: We determine if the euid is going to change, and do EPERM
 520          *    right away.  We unconditionally change the euid later if this
 521          *    test is satisfied, simplifying that part of the logic.
 522          * 2: We determine if the real and/or saved uids are going to
 523          *    change.  Determined by compile options.
 524          * 3: Change euid last. (after tests in #2 for "appropriate privs")
 525          */
 526         if (uid != oldcred->cr_ruid &&          /* allow setuid(getuid()) */
 527 #ifdef _POSIX_SAVED_IDS
 528             uid != oldcred->cr_svuid &&         /* allow setuid(saved gid) */
 529 #endif
 530 #ifdef POSIX_APPENDIX_B_4_2_2   /* Use BSD-compat clause from B.4.2.2 */
 531             uid != oldcred->cr_uid &&           /* allow setuid(geteuid()) */
 532 #endif
 533             (error = priv_check_cred(oldcred, PRIV_CRED_SETUID, 0)) != 0)
 534                 goto fail;
 535
 536 #ifdef _POSIX_SAVED_IDS
 537         /*
 538          * Do we have "appropriate privileges" (are we root or uid == euid)
 539          * If so, we are changing the real uid and/or saved uid.
 540          */
 541         if (
 542 #ifdef POSIX_APPENDIX_B_4_2_2   /* Use the clause from B.4.2.2 */
 543             uid == oldcred->cr_uid ||
 544 #endif
 545             /* We are using privs. */
 546             priv_check_cred(oldcred, PRIV_CRED_SETUID, 0) == 0)
 547 #endif
 548         {
 549                 /*
 550                  * Set the real uid and transfer proc count to new user.
 551                  */
 552                 if (uid != oldcred->cr_ruid) {
 553                         change_ruid(newcred, uip);
 554                         setsugid(p);
 555                 }
 556                 /*
 557                  * Set saved uid
 558                  *
 559                  * XXX always set saved uid even if not _POSIX_SAVED_IDS, as
 560                  * the security of seteuid() depends on it.  B.4.2.2 says it
 561                  * is important that we should do this.
 562                  */
 563                 if (uid != oldcred->cr_svuid) {
 564                         change_svuid(newcred, uid);
 565                         setsugid(p);
 566                 }
 567         }
 568
 569         /*
 570          * In all permitted cases, we are changing the euid.
 571          */
 572         if (uid != oldcred->cr_uid) {
 573                 change_euid(newcred, uip);
 574                 setsugid(p);
 575         }
 576         proc_set_cred(p, newcred);
 577         PROC_UNLOCK(p);
 578 #ifdef RACCT
 579         racct_proc_ucred_changed(p, oldcred, newcred);
 580 #endif
 581         uifree(uip);
 582         crfree(oldcred);
 583         return (0);
 584
 585 fail:
 586         PROC_UNLOCK(p);
 587         uifree(uip);
 588         crfree(newcred);
 589         return (error);
 590 }
 591
 592 #ifndef _SYS_SYSPROTO_H_
 593 struct seteuid_args {
 594         uid_t   euid;
 595 };
 596 #endif
 597 /* ARGSUSED */
 598 int
 599 sys_seteuid(struct thread *td, struct seteuid_args *uap)
 600 {
 601         struct proc *p = td->td_proc;
 602         struct ucred *newcred, *oldcred;
 603         uid_t euid;
 604         struct uidinfo *euip;
 605         int error;
 606
 607         euid = uap->euid;
 608         AUDIT_ARG_EUID(euid);
 609         newcred = crget();
 610         euip = uifind(euid);
 611         PROC_LOCK(p);
 612         /*
 613          * Copy credentials so other references do not see our changes.
 614          */
 615         oldcred = crcopysafe(p, newcred);
 616
 617 #ifdef MAC
 618         error = mac_cred_check_seteuid(oldcred, euid);
 619         if (error)
 620                 goto fail;
 621 #endif
 622
 623         if (euid != oldcred->cr_ruid &&         /* allow seteuid(getuid()) */
 624             euid != oldcred->cr_svuid &&        /* allow seteuid(saved uid) */
 625             (error = priv_check_cred(oldcred, PRIV_CRED_SETEUID, 0)) != 0)
 626                 goto fail;
 627
 628         /*
 629          * Everything's okay, do it.
 630          */
 631         if (oldcred->cr_uid != euid) {
 632                 change_euid(newcred, euip);
 633                 setsugid(p);
 634         }
 635         proc_set_cred(p, newcred);
 636         PROC_UNLOCK(p);
 637         uifree(euip);
 638         crfree(oldcred);
 639         return (0);
 640
 641 fail:
 642         PROC_UNLOCK(p);
 643         uifree(euip);
 644         crfree(newcred);
 645         return (error);
 646 }
 647
 648 #ifndef _SYS_SYSPROTO_H_
 649 struct setgid_args {
 650         gid_t   gid;
 651 };
 652 #endif
 653 /* ARGSUSED */
 654 int
 655 sys_setgid(struct thread *td, struct setgid_args *uap)
 656 {
 657         struct proc *p = td->td_proc;
 658         struct ucred *newcred, *oldcred;
 659         gid_t gid;
 660         int error;
 661
 662         gid = uap->gid;
 663         AUDIT_ARG_GID(gid);
 664         newcred = crget();
 665         PROC_LOCK(p);
 666         oldcred = crcopysafe(p, newcred);
 667
 668 #ifdef MAC
 669         error = mac_cred_check_setgid(oldcred, gid);
 670         if (error)
 671                 goto fail;
 672 #endif
 673
 674         /*
 675          * See if we have "permission" by POSIX 1003.1 rules.
 676          *
 677          * Note that setgid(getegid()) is a special case of
 678          * "appropriate privileges" in appendix B.4.2.2.  We need
 679          * to use this clause to be compatible with traditional BSD
 680          * semantics.  Basically, it means that "setgid(xx)" sets all
 681          * three id's (assuming you have privs).
 682          *
 683          * For notes on the logic here, see setuid() above.
 684          */
 685         if (gid != oldcred->cr_rgid &&          /* allow setgid(getgid()) */
 686 #ifdef _POSIX_SAVED_IDS
 687             gid != oldcred->cr_svgid &&         /* allow setgid(saved gid) */
 688 #endif
 689 #ifdef POSIX_APPENDIX_B_4_2_2   /* Use BSD-compat clause from B.4.2.2 */
 690             gid != oldcred->cr_groups[0] && /* allow setgid(getegid()) */
 691 #endif
 692             (error = priv_check_cred(oldcred, PRIV_CRED_SETGID, 0)) != 0)
 693                 goto fail;
 694
 695 #ifdef _POSIX_SAVED_IDS
 696         /*
 697          * Do we have "appropriate privileges" (are we root or gid == egid)
 698          * If so, we are changing the real uid and saved gid.
 699          */
 700         if (
 701 #ifdef POSIX_APPENDIX_B_4_2_2   /* use the clause from B.4.2.2 */
 702             gid == oldcred->cr_groups[0] ||
 703 #endif
 704             /* We are using privs. */
 705             priv_check_cred(oldcred, PRIV_CRED_SETGID, 0) == 0)
 706 #endif
 707         {
 708                 /*
 709                  * Set real gid
 710                  */
 711                 if (oldcred->cr_rgid != gid) {
 712                         change_rgid(newcred, gid);
 713                         setsugid(p);
 714                 }
 715                 /*
 716                  * Set saved gid
 717                  *
 718                  * XXX always set saved gid even if not _POSIX_SAVED_IDS, as
 719                  * the security of setegid() depends on it.  B.4.2.2 says it
 720                  * is important that we should do this.
 721                  */
 722                 if (oldcred->cr_svgid != gid) {
 723                         change_svgid(newcred, gid);
 724                         setsugid(p);
 725                 }
 726         }
 727         /*
 728          * In all cases permitted cases, we are changing the egid.
 729          * Copy credentials so other references do not see our changes.
 730          */
 731         if (oldcred->cr_groups[0] != gid) {
 732                 change_egid(newcred, gid);
 733                 setsugid(p);
 734         }
 735         proc_set_cred(p, newcred);
 736         PROC_UNLOCK(p);
 737         crfree(oldcred);
 738         return (0);
 739
 740 fail:
 741         PROC_UNLOCK(p);
 742         crfree(newcred);
 743         return (error);
 744 }
 745
 746 #ifndef _SYS_SYSPROTO_H_
 747 struct setegid_args {
 748         gid_t   egid;
 749 };
 750 #endif
 751 /* ARGSUSED */
 752 int
 753 sys_setegid(struct thread *td, struct setegid_args *uap)
 754 {
 755         struct proc *p = td->td_proc;
 756         struct ucred *newcred, *oldcred;
 757         gid_t egid;
 758         int error;
 759
 760         egid = uap->egid;
 761         AUDIT_ARG_EGID(egid);
 762         newcred = crget();
 763         PROC_LOCK(p);
 764         oldcred = crcopysafe(p, newcred);
 765
 766 #ifdef MAC
 767         error = mac_cred_check_setegid(oldcred, egid);
 768         if (error)
 769                 goto fail;
 770 #endif
 771
 772         if (egid != oldcred->cr_rgid &&         /* allow setegid(getgid()) */
 773             egid != oldcred->cr_svgid &&        /* allow setegid(saved gid) */
 774             (error = priv_check_cred(oldcred, PRIV_CRED_SETEGID, 0)) != 0)
 775                 goto fail;
 776
 777         if (oldcred->cr_groups[0] != egid) {
 778                 change_egid(newcred, egid);
 779                 setsugid(p);
 780         }
 781         proc_set_cred(p, newcred);
 782         PROC_UNLOCK(p);
 783         crfree(oldcred);
 784         return (0);
 785
 786 fail:
 787         PROC_UNLOCK(p);
 788         crfree(newcred);
 789         return (error);
 790 }
 791
 792 #ifndef _SYS_SYSPROTO_H_
 793 struct setgroups_args {
 794         u_int   gidsetsize;
 795         gid_t   *gidset;
 796 };
 797 #endif
 798 /* ARGSUSED */
 799 int
 800 sys_setgroups(struct thread *td, struct setgroups_args *uap)
 801 {
 802         gid_t smallgroups[XU_NGROUPS];
 803         gid_t *groups;
 804         u_int gidsetsize;
 805         int error;
 806
 807         gidsetsize = uap->gidsetsize;
 808         if (gidsetsize > ngroups_max + 1)
 809                 return (EINVAL);
 810
 811         if (gidsetsize > XU_NGROUPS)
 812                 groups = malloc(gidsetsize * sizeof(gid_t), M_TEMP, M_WAITOK);
 813         else
 814                 groups = smallgroups;
 815
 816         error = copyin(uap->gidset, groups, gidsetsize * sizeof(gid_t));
 817         if (error == 0)
 818                 error = kern_setgroups(td, gidsetsize, groups);
 819
 820         if (gidsetsize > XU_NGROUPS)
 821                 free(groups, M_TEMP);
 822         return (error);
 823 }
 824
 825 int
 826 kern_setgroups(struct thread *td, u_int ngrp, gid_t *groups)
 827 {
 828         struct proc *p = td->td_proc;
 829         struct ucred *newcred, *oldcred;
 830         int error;
 831
 832         MPASS(ngrp <= ngroups_max + 1);
 833         AUDIT_ARG_GROUPSET(groups, ngrp);
 834         newcred = crget();
 835         crextend(newcred, ngrp);
 836         PROC_LOCK(p);
 837         oldcred = crcopysafe(p, newcred);
 838
 839 #ifdef MAC
 840         error = mac_cred_check_setgroups(oldcred, ngrp, groups);
 841         if (error)
 842                 goto fail;
 843 #endif
 844
 845         error = priv_check_cred(oldcred, PRIV_CRED_SETGROUPS, 0);
 846         if (error)
 847                 goto fail;
 848
 849         if (ngrp == 0) {
 850                 /*
 851                  * setgroups(0, NULL) is a legitimate way of clearing the
 852                  * groups vector on non-BSD systems (which generally do not
 853                  * have the egid in the groups[0]).  We risk security holes
 854                  * when running non-BSD software if we do not do the same.
 855                  */
 856                 newcred->cr_ngroups = 1;
 857         } else {
 858                 crsetgroups_locked(newcred, ngrp, groups);
 859         }
 860         setsugid(p);
 861         proc_set_cred(p, newcred);
 862         PROC_UNLOCK(p);
 863         crfree(oldcred);
 864         return (0);
 865
 866 fail:
 867         PROC_UNLOCK(p);
 868         crfree(newcred);
 869         return (error);
 870 }
 871
 872 #ifndef _SYS_SYSPROTO_H_
 873 struct setreuid_args {
 874         uid_t   ruid;
 875         uid_t   euid;
 876 };
 877 #endif
 878 /* ARGSUSED */
 879 int
 880 sys_setreuid(register struct thread *td, struct setreuid_args *uap)
 881 {
 882         struct proc *p = td->td_proc;
 883         struct ucred *newcred, *oldcred;
 884         uid_t euid, ruid;
 885         struct uidinfo *euip, *ruip;
 886         int error;
 887
 888         euid = uap->euid;
 889         ruid = uap->ruid;
 890         AUDIT_ARG_EUID(euid);
 891         AUDIT_ARG_RUID(ruid);
 892         newcred = crget();
 893         euip = uifind(euid);
 894         ruip = uifind(ruid);
 895         PROC_LOCK(p);
 896         oldcred = crcopysafe(p, newcred);
 897
 898 #ifdef MAC
 899         error = mac_cred_check_setreuid(oldcred, ruid, euid);
 900         if (error)
 901                 goto fail;
 902 #endif
 903
 904         if (((ruid != (uid_t)-1 && ruid != oldcred->cr_ruid &&
 905               ruid != oldcred->cr_svuid) ||
 906              (euid != (uid_t)-1 && euid != oldcred->cr_uid &&
 907               euid != oldcred->cr_ruid && euid != oldcred->cr_svuid)) &&
 908             (error = priv_check_cred(oldcred, PRIV_CRED_SETREUID, 0)) != 0)
 909                 goto fail;
 910
 911         if (euid != (uid_t)-1 && oldcred->cr_uid != euid) {
 912                 change_euid(newcred, euip);
 913                 setsugid(p);
 914         }
 915         if (ruid != (uid_t)-1 && oldcred->cr_ruid != ruid) {
 916                 change_ruid(newcred, ruip);
 917                 setsugid(p);
 918         }
 919         if ((ruid != (uid_t)-1 || newcred->cr_uid != newcred->cr_ruid) &&
 920             newcred->cr_svuid != newcred->cr_uid) {
 921                 change_svuid(newcred, newcred->cr_uid);
 922                 setsugid(p);
 923         }
 924         proc_set_cred(p, newcred);
 925         PROC_UNLOCK(p);
 926 #ifdef RACCT
 927         racct_proc_ucred_changed(p, oldcred, newcred);
 928 #endif
 929         uifree(ruip);
 930         uifree(euip);
 931         crfree(oldcred);
 932         return (0);
 933
 934 fail:
 935         PROC_UNLOCK(p);
 936         uifree(ruip);
 937         uifree(euip);
 938         crfree(newcred);
 939         return (error);
 940 }
 941
 942 #ifndef _SYS_SYSPROTO_H_
 943 struct setregid_args {
 944         gid_t   rgid;
 945         gid_t   egid;
 946 };
 947 #endif
 948 /* ARGSUSED */
 949 int
 950 sys_setregid(register struct thread *td, struct setregid_args *uap)
 951 {
 952         struct proc *p = td->td_proc;
 953         struct ucred *newcred, *oldcred;
 954         gid_t egid, rgid;
 955         int error;
 956
 957         egid = uap->egid;
 958         rgid = uap->rgid;
 959         AUDIT_ARG_EGID(egid);
 960         AUDIT_ARG_RGID(rgid);
 961         newcred = crget();
 962         PROC_LOCK(p);
 963         oldcred = crcopysafe(p, newcred);
 964
 965 #ifdef MAC
 966         error = mac_cred_check_setregid(oldcred, rgid, egid);
 967         if (error)
 968                 goto fail;
 969 #endif
 970
 971         if (((rgid != (gid_t)-1 && rgid != oldcred->cr_rgid &&
 972             rgid != oldcred->cr_svgid) ||
 973              (egid != (gid_t)-1 && egid != oldcred->cr_groups[0] &&
 974              egid != oldcred->cr_rgid && egid != oldcred->cr_svgid)) &&
 975             (error = priv_check_cred(oldcred, PRIV_CRED_SETREGID, 0)) != 0)
 976                 goto fail;
 977
 978         if (egid != (gid_t)-1 && oldcred->cr_groups[0] != egid) {
 979                 change_egid(newcred, egid);
 980                 setsugid(p);
 981         }
 982         if (rgid != (gid_t)-1 && oldcred->cr_rgid != rgid) {
 983                 change_rgid(newcred, rgid);
 984                 setsugid(p);
 985         }
 986         if ((rgid != (gid_t)-1 || newcred->cr_groups[0] != newcred->cr_rgid) &&
 987             newcred->cr_svgid != newcred->cr_groups[0]) {
 988                 change_svgid(newcred, newcred->cr_groups[0]);
 989                 setsugid(p);
 990         }
 991         proc_set_cred(p, newcred);
 992         PROC_UNLOCK(p);
 993         crfree(oldcred);
 994         return (0);
 995
 996 fail:
 997         PROC_UNLOCK(p);
 998         crfree(newcred);
 999         return (error);
1000 }
1001
1002 /*
1003  * setresuid(ruid, euid, suid) is like setreuid except control over the saved
1004  * uid is explicit.
1005  */
1006 #ifndef _SYS_SYSPROTO_H_
1007 struct setresuid_args {
1008         uid_t   ruid;
1009         uid_t   euid;
1010         uid_t   suid;
1011 };
1012 #endif
1013 /* ARGSUSED */
1014 int
1015 sys_setresuid(register struct thread *td, struct setresuid_args *uap)
1016 {
1017         struct proc *p = td->td_proc;
1018         struct ucred *newcred, *oldcred;
1019         uid_t euid, ruid, suid;
1020         struct uidinfo *euip, *ruip;
1021         int error;
1022
1023         euid = uap->euid;
1024         ruid = uap->ruid;
1025         suid = uap->suid;
1026         AUDIT_ARG_EUID(euid);
1027         AUDIT_ARG_RUID(ruid);
1028         AUDIT_ARG_SUID(suid);
1029         newcred = crget();
1030         euip = uifind(euid);
1031         ruip = uifind(ruid);
1032         PROC_LOCK(p);
1033         oldcred = crcopysafe(p, newcred);
1034
1035 #ifdef MAC
1036         error = mac_cred_check_setresuid(oldcred, ruid, euid, suid);
1037         if (error)
1038                 goto fail;
1039 #endif
1040
1041         if (((ruid != (uid_t)-1 && ruid != oldcred->cr_ruid &&
1042              ruid != oldcred->cr_svuid &&
1043               ruid != oldcred->cr_uid) ||
1044              (euid != (uid_t)-1 && euid != oldcred->cr_ruid &&
1045             euid != oldcred->cr_svuid &&
1046               euid != oldcred->cr_uid) ||
1047              (suid != (uid_t)-1 && suid != oldcred->cr_ruid &&
1048             suid != oldcred->cr_svuid &&
1049               suid != oldcred->cr_uid)) &&
1050             (error = priv_check_cred(oldcred, PRIV_CRED_SETRESUID, 0)) != 0)
1051                 goto fail;
1052
1053         if (euid != (uid_t)-1 && oldcred->cr_uid != euid) {
1054                 change_euid(newcred, euip);
1055                 setsugid(p);
1056         }
1057         if (ruid != (uid_t)-1 && oldcred->cr_ruid != ruid) {
1058                 change_ruid(newcred, ruip);
1059                 setsugid(p);
1060         }
1061         if (suid != (uid_t)-1 && oldcred->cr_svuid != suid) {
1062                 change_svuid(newcred, suid);
1063                 setsugid(p);
1064         }
1065         proc_set_cred(p, newcred);
1066         PROC_UNLOCK(p);
1067 #ifdef RACCT
1068         racct_proc_ucred_changed(p, oldcred, newcred);
1069 #endif
1070         uifree(ruip);
1071         uifree(euip);
1072         crfree(oldcred);
1073         return (0);
1074
1075 fail:
1076         PROC_UNLOCK(p);
1077         uifree(ruip);
1078         uifree(euip);
1079         crfree(newcred);
1080         return (error);
1081
1082 }
1083
1084 /*
1085  * setresgid(rgid, egid, sgid) is like setregid except control over the saved
1086  * gid is explicit.
1087  */
1088 #ifndef _SYS_SYSPROTO_H_
1089 struct setresgid_args {
1090         gid_t   rgid;
1091         gid_t   egid;
1092         gid_t   sgid;
1093 };
1094 #endif
1095 /* ARGSUSED */
1096 int
1097 sys_setresgid(register struct thread *td, struct setresgid_args *uap)
1098 {
1099         struct proc *p = td->td_proc;
1100         struct ucred *newcred, *oldcred;
1101         gid_t egid, rgid, sgid;
1102         int error;
1103
1104         egid = uap->egid;
1105         rgid = uap->rgid;
1106         sgid = uap->sgid;
1107         AUDIT_ARG_EGID(egid);
1108         AUDIT_ARG_RGID(rgid);
1109         AUDIT_ARG_SGID(sgid);
1110         newcred = crget();
1111         PROC_LOCK(p);
1112         oldcred = crcopysafe(p, newcred);
1113
1114 #ifdef MAC
1115         error = mac_cred_check_setresgid(oldcred, rgid, egid, sgid);
1116         if (error)
1117                 goto fail;
1118 #endif
1119
1120         if (((rgid != (gid_t)-1 && rgid != oldcred->cr_rgid &&
1121               rgid != oldcred->cr_svgid &&
1122               rgid != oldcred->cr_groups[0]) ||
1123              (egid != (gid_t)-1 && egid != oldcred->cr_rgid &&
1124               egid != oldcred->cr_svgid &&
1125               egid != oldcred->cr_groups[0]) ||
1126              (sgid != (gid_t)-1 && sgid != oldcred->cr_rgid &&
1127               sgid != oldcred->cr_svgid &&
1128               sgid != oldcred->cr_groups[0])) &&
1129             (error = priv_check_cred(oldcred, PRIV_CRED_SETRESGID, 0)) != 0)
1130                 goto fail;
1131
1132         if (egid != (gid_t)-1 && oldcred->cr_groups[0] != egid) {
1133                 change_egid(newcred, egid);
1134                 setsugid(p);
1135         }
1136         if (rgid != (gid_t)-1 && oldcred->cr_rgid != rgid) {
1137                 change_rgid(newcred, rgid);
1138                 setsugid(p);
1139         }
1140         if (sgid != (gid_t)-1 && oldcred->cr_svgid != sgid) {
1141                 change_svgid(newcred, sgid);
1142                 setsugid(p);
1143         }
1144         proc_set_cred(p, newcred);
1145         PROC_UNLOCK(p);
1146         crfree(oldcred);
1147         return (0);
1148
1149 fail:
1150         PROC_UNLOCK(p);
1151         crfree(newcred);
1152         return (error);
1153 }
1154
1155 #ifndef _SYS_SYSPROTO_H_
1156 struct getresuid_args {
1157         uid_t   *ruid;
1158         uid_t   *euid;
1159         uid_t   *suid;
1160 };
1161 #endif
1162 /* ARGSUSED */
1163 int
1164 sys_getresuid(register struct thread *td, struct getresuid_args *uap)
1165 {
1166         struct ucred *cred;
1167         int error1 = 0, error2 = 0, error3 = 0;
1168
1169         cred = td->td_ucred;
1170         if (uap->ruid)
1171                 error1 = copyout(&cred->cr_ruid,
1172                     uap->ruid, sizeof(cred->cr_ruid));
1173         if (uap->euid)
1174                 error2 = copyout(&cred->cr_uid,
1175                     uap->euid, sizeof(cred->cr_uid));
1176         if (uap->suid)
1177                 error3 = copyout(&cred->cr_svuid,
1178                     uap->suid, sizeof(cred->cr_svuid));
1179         return (error1 ? error1 : error2 ? error2 : error3);
1180 }
1181
1182 #ifndef _SYS_SYSPROTO_H_
1183 struct getresgid_args {
1184         gid_t   *rgid;
1185         gid_t   *egid;
1186         gid_t   *sgid;
1187 };
1188 #endif
1189 /* ARGSUSED */
1190 int
1191 sys_getresgid(register struct thread *td, struct getresgid_args *uap)
1192 {
1193         struct ucred *cred;
1194         int error1 = 0, error2 = 0, error3 = 0;
1195
1196         cred = td->td_ucred;
1197         if (uap->rgid)
1198                 error1 = copyout(&cred->cr_rgid,
1199                     uap->rgid, sizeof(cred->cr_rgid));
1200         if (uap->egid)
1201                 error2 = copyout(&cred->cr_groups[0],
1202                     uap->egid, sizeof(cred->cr_groups[0]));
1203         if (uap->sgid)
1204                 error3 = copyout(&cred->cr_svgid,
1205                     uap->sgid, sizeof(cred->cr_svgid));
1206         return (error1 ? error1 : error2 ? error2 : error3);
1207 }
1208
1209 #ifndef _SYS_SYSPROTO_H_
1210 struct issetugid_args {
1211         int dummy;
1212 };
1213 #endif
1214 /* ARGSUSED */
1215 int
1216 sys_issetugid(register struct thread *td, struct issetugid_args *uap)
1217 {
1218         struct proc *p = td->td_proc;
1219
1220         /*
1221          * Note: OpenBSD sets a P_SUGIDEXEC flag set at execve() time,
1222          * we use P_SUGID because we consider changing the owners as
1223          * "tainting" as well.
1224          * This is significant for procs that start as root and "become"
1225          * a user without an exec - programs cannot know *everything*
1226          * that libc *might* have put in their data segment.
1227          */
1228         td->td_retval[0] = (p->p_flag & P_SUGID) ? 1 : 0;
1229         return (0);
1230 }
1231
1232 int
1233 sys___setugid(struct thread *td, struct __setugid_args *uap)
1234 {
1235 #ifdef REGRESSION
1236         struct proc *p;
1237
1238         p = td->td_proc;
1239         switch (uap->flag) {
1240         case 0:
1241                 PROC_LOCK(p);
1242                 p->p_flag &= ~P_SUGID;
1243                 PROC_UNLOCK(p);
1244                 return (0);
1245         case 1:
1246                 PROC_LOCK(p);
1247                 p->p_flag |= P_SUGID;
1248                 PROC_UNLOCK(p);
1249                 return (0);
1250         default:
1251                 return (EINVAL);
1252         }
1253 #else /* !REGRESSION */
1254
1255         return (ENOSYS);
1256 #endif /* REGRESSION */
1257 }
1258
1259 /*
1260  * Check if gid is a member of the group set.
1261  */
1262 int
1263 groupmember(gid_t gid, struct ucred *cred)
1264 {
1265         int l;
1266         int h;
1267         int m;
1268
1269         if (cred->cr_groups[0] == gid)
1270                 return(1);
1271
1272         /*
1273          * If gid was not our primary group, perform a binary search
1274          * of the supplemental groups.  This is possible because we
1275          * sort the groups in crsetgroups().
1276          */
1277         l = 1;
1278         h = cred->cr_ngroups;
1279         while (l < h) {
1280                 m = l + ((h - l) / 2);
1281                 if (cred->cr_groups[m] < gid)
1282                         l = m + 1;
1283                 else
1284                         h = m;
1285         }
1286         if ((l < cred->cr_ngroups) && (cred->cr_groups[l] == gid))
1287                 return (1);
1288
1289         return (0);
1290 }
1291
1292 /*
1293  * Test the active securelevel against a given level.  securelevel_gt()
1294  * implements (securelevel > level).  securelevel_ge() implements
1295  * (securelevel >= level).  Note that the logic is inverted -- these
1296  * functions return EPERM on "success" and 0 on "failure".
1297  *
1298  * Due to care taken when setting the securelevel, we know that no jail will
1299  * be less secure that its parent (or the physical system), so it is sufficient
1300  * to test the current jail only.
1301  *
1302  * XXXRW: Possibly since this has to do with privilege, it should move to
1303  * kern_priv.c.
1304  */
1305 int
1306 securelevel_gt(struct ucred *cr, int level)
1307 {
1308
1309         return (cr->cr_prison->pr_securelevel > level ? EPERM : 0);
1310 }
1311
1312 int
1313 securelevel_ge(struct ucred *cr, int level)
1314 {
1315
1316         return (cr->cr_prison->pr_securelevel >= level ? EPERM : 0);
1317 }
1318
1319 /*
1320  * 'see_other_uids' determines whether or not visibility of processes
1321  * and sockets with credentials holding different real uids is possible
1322  * using a variety of system MIBs.
1323  * XXX: data declarations should be together near the beginning of the file.
1324  */
1325 static int      see_other_uids = 1;
1326 SYSCTL_INT(_security_bsd, OID_AUTO, see_other_uids, CTLFLAG_RW,
1327     &see_other_uids, 0,
1328     "Unprivileged processes may see subjects/objects with different real uid");
1329
1330 /*-
1331  * Determine if u1 "can see" the subject specified by u2, according to the
1332  * 'see_other_uids' policy.
1333  * Returns: 0 for permitted, ESRCH otherwise
1334  * Locks: none
1335  * References: *u1 and *u2 must not change during the call
1336  *             u1 may equal u2, in which case only one reference is required
1337  */
1338 int
1339 cr_canseeotheruids(struct ucred *u1, struct ucred *u2)
1340 {
1341
1342         if (!see_other_uids && u1->cr_ruid != u2->cr_ruid) {
1343                 if (priv_check_cred(u1, PRIV_SEEOTHERUIDS, 0) != 0)
1344                         return (ESRCH);
1345         }
1346         return (0);
1347 }
1348
1349 /*
1350  * 'see_other_gids' determines whether or not visibility of processes
1351  * and sockets with credentials holding different real gids is possible
1352  * using a variety of system MIBs.
1353  * XXX: data declarations should be together near the beginning of the file.
1354  */
1355 static int      see_other_gids = 1;
1356 SYSCTL_INT(_security_bsd, OID_AUTO, see_other_gids, CTLFLAG_RW,
1357     &see_other_gids, 0,
1358     "Unprivileged processes may see subjects/objects with different real gid");
1359
1360 /*
1361  * Determine if u1 can "see" the subject specified by u2, according to the
1362  * 'see_other_gids' policy.
1363  * Returns: 0 for permitted, ESRCH otherwise
1364  * Locks: none
1365  * References: *u1 and *u2 must not change during the call
1366  *             u1 may equal u2, in which case only one reference is required
1367  */
1368 int
1369 cr_canseeothergids(struct ucred *u1, struct ucred *u2)
1370 {
1371         int i, match;
1372
1373         if (!see_other_gids) {
1374                 match = 0;
1375                 for (i = 0; i < u1->cr_ngroups; i++) {
1376                         if (groupmember(u1->cr_groups[i], u2))
1377                                 match = 1;
1378                         if (match)
1379                                 break;
1380                 }
1381                 if (!match) {
1382                         if (priv_check_cred(u1, PRIV_SEEOTHERGIDS, 0) != 0)
1383                                 return (ESRCH);
1384                 }
1385         }
1386         return (0);
1387 }
1388
1389 /*-
1390  * Determine if u1 "can see" the subject specified by u2.
1391  * Returns: 0 for permitted, an errno value otherwise
1392  * Locks: none
1393  * References: *u1 and *u2 must not change during the call
1394  *             u1 may equal u2, in which case only one reference is required
1395  */
1396 int
1397 cr_cansee(struct ucred *u1, struct ucred *u2)
1398 {
1399         int error;
1400
1401         if ((error = prison_check(u1, u2)))
1402                 return (error);
1403 #ifdef MAC
1404         if ((error = mac_cred_check_visible(u1, u2)))
1405                 return (error);
1406 #endif
1407         if ((error = cr_canseeotheruids(u1, u2)))
1408                 return (error);
1409         if ((error = cr_canseeothergids(u1, u2)))
1410                 return (error);
1411         return (0);
1412 }
1413
1414 /*-
1415  * Determine if td "can see" the subject specified by p.
1416  * Returns: 0 for permitted, an errno value otherwise
1417  * Locks: Sufficient locks to protect p->p_ucred must be held.  td really
1418  *        should be curthread.
1419  * References: td and p must be valid for the lifetime of the call
1420  */
1421 int
1422 p_cansee(struct thread *td, struct proc *p)
1423 {
1424
1425         /* Wrap cr_cansee() for all functionality. */
1426         KASSERT(td == curthread, ("%s: td not curthread", __func__));
1427         PROC_LOCK_ASSERT(p, MA_OWNED);
1428         return (cr_cansee(td->td_ucred, p->p_ucred));
1429 }
1430
1431 /*
1432  * 'conservative_signals' prevents the delivery of a broad class of
1433  * signals by unprivileged processes to processes that have changed their
1434  * credentials since the last invocation of execve().  This can prevent
1435  * the leakage of cached information or retained privileges as a result
1436  * of a common class of signal-related vulnerabilities.  However, this
1437  * may interfere with some applications that expect to be able to
1438  * deliver these signals to peer processes after having given up
1439  * privilege.
1440  */
1441 static int      conservative_signals = 1;
1442 SYSCTL_INT(_security_bsd, OID_AUTO, conservative_signals, CTLFLAG_RW,
1443     &conservative_signals, 0, "Unprivileged processes prevented from "
1444     "sending certain signals to processes whose credentials have changed");
1445 /*-
1446  * Determine whether cred may deliver the specified signal to proc.
1447  * Returns: 0 for permitted, an errno value otherwise.
1448  * Locks: A lock must be held for proc.
1449  * References: cred and proc must be valid for the lifetime of the call.
1450  */
1451 int
1452 cr_cansignal(struct ucred *cred, struct proc *proc, int signum)
1453 {
1454         int error;
1455
1456         PROC_LOCK_ASSERT(proc, MA_OWNED);
1457         /*
1458          * Jail semantics limit the scope of signalling to proc in the
1459          * same jail as cred, if cred is in jail.
1460          */
1461         error = prison_check(cred, proc->p_ucred);
1462         if (error)
1463                 return (error);
1464 #ifdef MAC
1465         if ((error = mac_proc_check_signal(cred, proc, signum)))
1466                 return (error);
1467 #endif
1468         if ((error = cr_canseeotheruids(cred, proc->p_ucred)))
1469                 return (error);
1470         if ((error = cr_canseeothergids(cred, proc->p_ucred)))
1471                 return (error);
1472
1473         /*
1474          * UNIX signal semantics depend on the status of the P_SUGID
1475          * bit on the target process.  If the bit is set, then additional
1476          * restrictions are placed on the set of available signals.
1477          */
1478         if (conservative_signals && (proc->p_flag & P_SUGID)) {
1479                 switch (signum) {
1480                 case 0:
1481                 case SIGKILL:
1482                 case SIGINT:
1483                 case SIGTERM:
1484                 case SIGALRM:
1485                 case SIGSTOP:
1486                 case SIGTTIN:
1487                 case SIGTTOU:
1488                 case SIGTSTP:
1489                 case SIGHUP:
1490                 case SIGUSR1:
1491                 case SIGUSR2:
1492                         /*
1493                          * Generally, permit job and terminal control
1494                          * signals.
1495                          */
1496                         break;
1497                 default:
1498                         /* Not permitted without privilege. */
1499                         error = priv_check_cred(cred, PRIV_SIGNAL_SUGID, 0);
1500                         if (error)
1501                                 return (error);
1502                 }
1503         }
1504
1505         /*
1506          * Generally, the target credential's ruid or svuid must match the
1507          * subject credential's ruid or euid.
1508          */
1509         if (cred->cr_ruid != proc->p_ucred->cr_ruid &&
1510             cred->cr_ruid != proc->p_ucred->cr_svuid &&
1511             cred->cr_uid != proc->p_ucred->cr_ruid &&
1512             cred->cr_uid != proc->p_ucred->cr_svuid) {
1513                 error = priv_check_cred(cred, PRIV_SIGNAL_DIFFCRED, 0);
1514                 if (error)
1515                         return (error);
1516         }
1517
1518         return (0);
1519 }
1520
1521 /*-
1522  * Determine whether td may deliver the specified signal to p.
1523  * Returns: 0 for permitted, an errno value otherwise
1524  * Locks: Sufficient locks to protect various components of td and p
1525  *        must be held.  td must be curthread, and a lock must be
1526  *        held for p.
1527  * References: td and p must be valid for the lifetime of the call
1528  */
1529 int
1530 p_cansignal(struct thread *td, struct proc *p, int signum)
1531 {
1532
1533         KASSERT(td == curthread, ("%s: td not curthread", __func__));
1534         PROC_LOCK_ASSERT(p, MA_OWNED);
1535         if (td->td_proc == p)
1536                 return (0);
1537
1538         /*
1539          * UNIX signalling semantics require that processes in the same
1540          * session always be able to deliver SIGCONT to one another,
1541          * overriding the remaining protections.
1542          */
1543         /* XXX: This will require an additional lock of some sort. */
1544         if (signum == SIGCONT && td->td_proc->p_session == p->p_session)
1545                 return (0);
1546         /*
1547          * Some compat layers use SIGTHR and higher signals for
1548          * communication between different kernel threads of the same
1549          * process, so that they expect that it's always possible to
1550          * deliver them, even for suid applications where cr_cansignal() can
1551          * deny such ability for security consideration.  It should be
1552          * pretty safe to do since the only way to create two processes
1553          * with the same p_leader is via rfork(2).
1554          */
1555         if (td->td_proc->p_leader != NULL && signum >= SIGTHR &&
1556             signum < SIGTHR + 4 && td->td_proc->p_leader == p->p_leader)
1557                 return (0);
1558
1559         return (cr_cansignal(td->td_ucred, p, signum));
1560 }
1561
1562 /*-
1563  * Determine whether td may reschedule p.
1564  * Returns: 0 for permitted, an errno value otherwise
1565  * Locks: Sufficient locks to protect various components of td and p
1566  *        must be held.  td must be curthread, and a lock must
1567  *        be held for p.
1568  * References: td and p must be valid for the lifetime of the call
1569  */
1570 int
1571 p_cansched(struct thread *td, struct proc *p)
1572 {
1573         int error;
1574
1575         KASSERT(td == curthread, ("%s: td not curthread", __func__));
1576         PROC_LOCK_ASSERT(p, MA_OWNED);
1577         if (td->td_proc == p)
1578                 return (0);
1579         if ((error = prison_check(td->td_ucred, p->p_ucred)))
1580                 return (error);
1581 #ifdef MAC
1582         if ((error = mac_proc_check_sched(td->td_ucred, p)))
1583                 return (error);
1584 #endif
1585         if ((error = cr_canseeotheruids(td->td_ucred, p->p_ucred)))
1586                 return (error);
1587         if ((error = cr_canseeothergids(td->td_ucred, p->p_ucred)))
1588                 return (error);
1589         if (td->td_ucred->cr_ruid != p->p_ucred->cr_ruid &&
1590             td->td_ucred->cr_uid != p->p_ucred->cr_ruid) {
1591                 error = priv_check(td, PRIV_SCHED_DIFFCRED);
1592                 if (error)
1593                         return (error);
1594         }
1595         return (0);
1596 }
1597
1598 /*
1599  * The 'unprivileged_proc_debug' flag may be used to disable a variety of
1600  * unprivileged inter-process debugging services, including some procfs
1601  * functionality, ptrace(), and ktrace().  In the past, inter-process
1602  * debugging has been involved in a variety of security problems, and sites
1603  * not requiring the service might choose to disable it when hardening
1604  * systems.
1605  *
1606  * XXX: Should modifying and reading this variable require locking?
1607  * XXX: data declarations should be together near the beginning of the file.
1608  */
1609 static int      unprivileged_proc_debug = 1;
1610 SYSCTL_INT(_security_bsd, OID_AUTO, unprivileged_proc_debug, CTLFLAG_RW,
1611     &unprivileged_proc_debug, 0,
1612     "Unprivileged processes may use process debugging facilities");
1613
1614 /*-
1615  * Determine whether td may debug p.
1616  * Returns: 0 for permitted, an errno value otherwise
1617  * Locks: Sufficient locks to protect various components of td and p
1618  *        must be held.  td must be curthread, and a lock must
1619  *        be held for p.
1620  * References: td and p must be valid for the lifetime of the call
1621  */
1622 int
1623 p_candebug(struct thread *td, struct proc *p)
1624 {
1625         int credentialchanged, error, grpsubset, i, uidsubset;
1626
1627         KASSERT(td == curthread, ("%s: td not curthread", __func__));
1628         PROC_LOCK_ASSERT(p, MA_OWNED);
1629         if (!unprivileged_proc_debug) {
1630                 error = priv_check(td, PRIV_DEBUG_UNPRIV);
1631                 if (error)
1632                         return (error);
1633         }
1634         if (td->td_proc == p)
1635                 return (0);
1636         if ((error = prison_check(td->td_ucred, p->p_ucred)))
1637                 return (error);
1638 #ifdef MAC
1639         if ((error = mac_proc_check_debug(td->td_ucred, p)))
1640                 return (error);
1641 #endif
1642         if ((error = cr_canseeotheruids(td->td_ucred, p->p_ucred)))
1643                 return (error);
1644         if ((error = cr_canseeothergids(td->td_ucred, p->p_ucred)))
1645                 return (error);
1646
1647         /*
1648          * Is p's group set a subset of td's effective group set?  This
1649          * includes p's egid, group access list, rgid, and svgid.
1650          */
1651         grpsubset = 1;
1652         for (i = 0; i < p->p_ucred->cr_ngroups; i++) {
1653                 if (!groupmember(p->p_ucred->cr_groups[i], td->td_ucred)) {
1654                         grpsubset = 0;
1655                         break;
1656                 }
1657         }
1658         grpsubset = grpsubset &&
1659             groupmember(p->p_ucred->cr_rgid, td->td_ucred) &&
1660             groupmember(p->p_ucred->cr_svgid, td->td_ucred);
1661
1662         /*
1663          * Are the uids present in p's credential equal to td's
1664          * effective uid?  This includes p's euid, svuid, and ruid.
1665          */
1666         uidsubset = (td->td_ucred->cr_uid == p->p_ucred->cr_uid &&
1667             td->td_ucred->cr_uid == p->p_ucred->cr_svuid &&
1668             td->td_ucred->cr_uid == p->p_ucred->cr_ruid);
1669
1670         /*
1671          * Has the credential of the process changed since the last exec()?
1672          */
1673         credentialchanged = (p->p_flag & P_SUGID);
1674
1675         /*
1676          * If p's gids aren't a subset, or the uids aren't a subset,
1677          * or the credential has changed, require appropriate privilege
1678          * for td to debug p.
1679          */
1680         if (!grpsubset || !uidsubset) {
1681                 error = priv_check(td, PRIV_DEBUG_DIFFCRED);
1682                 if (error)
1683                         return (error);
1684         }
1685
1686         if (credentialchanged) {
1687                 error = priv_check(td, PRIV_DEBUG_SUGID);
1688                 if (error)
1689                         return (error);
1690         }
1691
1692         /* Can't trace init when securelevel > 0. */
1693         if (p == initproc) {
1694                 error = securelevel_gt(td->td_ucred, 0);
1695                 if (error)
1696                         return (error);
1697         }
1698
1699         /*
1700          * Can't trace a process that's currently exec'ing.
1701          *
1702          * XXX: Note, this is not a security policy decision, it's a
1703          * basic correctness/functionality decision.  Therefore, this check
1704          * should be moved to the caller's of p_candebug().
1705          */
1706         if ((p->p_flag & P_INEXEC) != 0)
1707                 return (EBUSY);
1708
1709         /* Denied explicitely */
1710         if ((p->p_flag2 & P2_NOTRACE) != 0) {
1711                 error = priv_check(td, PRIV_DEBUG_DENIED);
1712                 if (error != 0)
1713                         return (error);
1714         }
1715
1716         return (0);
1717 }
1718
1719 /*-
1720  * Determine whether the subject represented by cred can "see" a socket.
1721  * Returns: 0 for permitted, ENOENT otherwise.
1722  */
1723 int
1724 cr_canseesocket(struct ucred *cred, struct socket *so)
1725 {
1726         int error;
1727
1728         error = prison_check(cred, so->so_cred);
1729         if (error)
1730                 return (ENOENT);
1731 #ifdef MAC
1732         error = mac_socket_check_visible(cred, so);
1733         if (error)
1734                 return (error);
1735 #endif
1736         if (cr_canseeotheruids(cred, so->so_cred))
1737                 return (ENOENT);
1738         if (cr_canseeothergids(cred, so->so_cred))
1739                 return (ENOENT);
1740
1741         return (0);
1742 }
1743
1744 /*-
1745  * Determine whether td can wait for the exit of p.
1746  * Returns: 0 for permitted, an errno value otherwise
1747  * Locks: Sufficient locks to protect various components of td and p
1748  *        must be held.  td must be curthread, and a lock must
1749  *        be held for p.
1750  * References: td and p must be valid for the lifetime of the call
1751
1752  */
1753 int
1754 p_canwait(struct thread *td, struct proc *p)
1755 {
1756         int error;
1757
1758         KASSERT(td == curthread, ("%s: td not curthread", __func__));
1759         PROC_LOCK_ASSERT(p, MA_OWNED);
1760         if ((error = prison_check(td->td_ucred, p->p_ucred)))
1761                 return (error);
1762 #ifdef MAC
1763         if ((error = mac_proc_check_wait(td->td_ucred, p)))
1764                 return (error);
1765 #endif
1766 #if 0
1767         /* XXXMAC: This could have odd effects on some shells. */
1768         if ((error = cr_canseeotheruids(td->td_ucred, p->p_ucred)))
1769                 return (error);
1770 #endif
1771
1772         return (0);
1773 }
1774
1775 /*
1776  * Allocate a zeroed cred structure.
1777  */
1778 struct ucred *
1779 crget(void)
1780 {
1781         register struct ucred *cr;
1782
1783         cr = malloc(sizeof(*cr), M_CRED, M_WAITOK | M_ZERO);
1784         refcount_init(&cr->cr_ref, 1);
1785 #ifdef AUDIT
1786         audit_cred_init(cr);
1787 #endif
1788 #ifdef MAC
1789         mac_cred_init(cr);
1790 #endif
1791         cr->cr_groups = cr->cr_smallgroups;
1792         cr->cr_agroups =
1793             sizeof(cr->cr_smallgroups) / sizeof(cr->cr_smallgroups[0]);
1794         return (cr);
1795 }
1796
1797 /*
1798  * Claim another reference to a ucred structure.
1799  */
1800 struct ucred *
1801 crhold(struct ucred *cr)
1802 {
1803
1804         refcount_acquire(&cr->cr_ref);
1805         return (cr);
1806 }
1807
1808 /*
1809  * Free a cred structure.  Throws away space when ref count gets to 0.
1810  */
1811 void
1812 crfree(struct ucred *cr)
1813 {
1814
1815         KASSERT(cr->cr_ref > 0, ("bad ucred refcount: %d", cr->cr_ref));
1816         KASSERT(cr->cr_ref != 0xdeadc0de, ("dangling reference to ucred"));
1817         if (refcount_release(&cr->cr_ref)) {
1818                 /*
1819                  * Some callers of crget(), such as nfs_statfs(),
1820                  * allocate a temporary credential, but don't
1821                  * allocate a uidinfo structure.
1822                  */
1823                 if (cr->cr_uidinfo != NULL)
1824                         uifree(cr->cr_uidinfo);
1825                 if (cr->cr_ruidinfo != NULL)
1826                         uifree(cr->cr_ruidinfo);
1827                 /*
1828                  * Free a prison, if any.
1829                  */
1830                 if (cr->cr_prison != NULL)
1831                         prison_free(cr->cr_prison);
1832                 if (cr->cr_loginclass != NULL)
1833                         loginclass_free(cr->cr_loginclass);
1834 #ifdef AUDIT
1835                 audit_cred_destroy(cr);
1836 #endif
1837 #ifdef MAC
1838                 mac_cred_destroy(cr);
1839 #endif
1840                 if (cr->cr_groups != cr->cr_smallgroups)
1841                         free(cr->cr_groups, M_CRED);
1842                 free(cr, M_CRED);
1843         }
1844 }
1845
1846 /*
1847  * Copy a ucred's contents from a template.  Does not block.
1848  */
1849 void
1850 crcopy(struct ucred *dest, struct ucred *src)
1851 {
1852
1853         KASSERT(dest->cr_ref == 1, ("crcopy of shared ucred"));
1854         bcopy(&src->cr_startcopy, &dest->cr_startcopy,
1855             (unsigned)((caddr_t)&src->cr_endcopy -
1856                 (caddr_t)&src->cr_startcopy));
1857         crsetgroups(dest, src->cr_ngroups, src->cr_groups);
1858         uihold(dest->cr_uidinfo);
1859         uihold(dest->cr_ruidinfo);
1860         prison_hold(dest->cr_prison);
1861         loginclass_hold(dest->cr_loginclass);
1862 #ifdef AUDIT
1863         audit_cred_copy(src, dest);
1864 #endif
1865 #ifdef MAC
1866         mac_cred_copy(src, dest);
1867 #endif
1868 }
1869
1870 /*
1871  * Dup cred struct to a new held one.
1872  */
1873 struct ucred *
1874 crdup(struct ucred *cr)
1875 {
1876         struct ucred *newcr;
1877
1878         newcr = crget();
1879         crcopy(newcr, cr);
1880         return (newcr);
1881 }
1882
1883 /*
1884  * Fill in a struct xucred based on a struct ucred.
1885  */
1886 void
1887 cru2x(struct ucred *cr, struct xucred *xcr)
1888 {
1889         int ngroups;
1890
1891         bzero(xcr, sizeof(*xcr));
1892         xcr->cr_version = XUCRED_VERSION;
1893         xcr->cr_uid = cr->cr_uid;
1894
1895         ngroups = MIN(cr->cr_ngroups, XU_NGROUPS);
1896         xcr->cr_ngroups = ngroups;
1897         bcopy(cr->cr_groups, xcr->cr_groups,
1898             ngroups * sizeof(*cr->cr_groups));
1899 }
1900
1901 /*
1902  * Set initial process credentials.
1903  * Callers are responsible for providing the reference for provided credentials.
1904  */
1905 void
1906 proc_set_cred_init(struct proc *p, struct ucred *newcred)
1907 {
1908
1909         p->p_ucred = newcred;
1910 }
1911
1912 /*
1913  * Change process credentials.
1914  * Callers are responsible for providing the reference for passed credentials
1915  * and for freeing old ones.
1916  *
1917  * Process has to be locked except when it does not have credentials (as it
1918  * should not be visible just yet) or when newcred is NULL (as this can be
1919  * only used when the process is about to be freed, at which point it should
1920  * not be visible anymore).
1921  */
1922 struct ucred *
1923 proc_set_cred(struct proc *p, struct ucred *newcred)
1924 {
1925         struct ucred *oldcred;
1926
1927         MPASS(p->p_ucred != NULL);
1928         if (newcred == NULL)
1929                 MPASS(p->p_state == PRS_ZOMBIE);
1930         else
1931                 PROC_LOCK_ASSERT(p, MA_OWNED);
1932
1933         oldcred = p->p_ucred;
1934         p->p_ucred = newcred;
1935         if (newcred != NULL)
1936                 PROC_UPDATE_COW(p);
1937         return (oldcred);
1938 }
1939
1940 struct ucred *
1941 crcopysafe(struct proc *p, struct ucred *cr)
1942 {
1943         struct ucred *oldcred;
1944         int groups;
1945
1946         PROC_LOCK_ASSERT(p, MA_OWNED);
1947
1948         oldcred = p->p_ucred;
1949         while (cr->cr_agroups < oldcred->cr_agroups) {
1950                 groups = oldcred->cr_agroups;
1951                 PROC_UNLOCK(p);
1952                 crextend(cr, groups);
1953                 PROC_LOCK(p);
1954                 oldcred = p->p_ucred;
1955         }
1956         crcopy(cr, oldcred);
1957
1958         return (oldcred);
1959 }
1960
1961 /*
1962  * Extend the passed in credential to hold n items.
1963  */
1964 void
1965 crextend(struct ucred *cr, int n)
1966 {
1967         int cnt;
1968
1969         /* Truncate? */
1970         if (n <= cr->cr_agroups)
1971                 return;
1972
1973         /*
1974          * We extend by 2 each time since we're using a power of two
1975          * allocator until we need enough groups to fill a page.
1976          * Once we're allocating multiple pages, only allocate as many
1977          * as we actually need.  The case of processes needing a
1978          * non-power of two number of pages seems more likely than
1979          * a real world process that adds thousands of groups one at a
1980          * time.
1981          */
1982         if ( n < PAGE_SIZE / sizeof(gid_t) ) {
1983                 if (cr->cr_agroups == 0)
1984                         cnt = MINALLOCSIZE / sizeof(gid_t);
1985                 else
1986                         cnt = cr->cr_agroups * 2;
1987
1988                 while (cnt < n)
1989                         cnt *= 2;
1990         } else
1991                 cnt = roundup2(n, PAGE_SIZE / sizeof(gid_t));
1992
1993         /* Free the old array. */
1994         if (cr->cr_groups != cr->cr_smallgroups)
1995                 free(cr->cr_groups, M_CRED);
1996
1997         cr->cr_groups = malloc(cnt * sizeof(gid_t), M_CRED, M_WAITOK | M_ZERO);
1998         cr->cr_agroups = cnt;
1999 }
2000
2001 /*
2002  * Copy groups in to a credential, preserving any necessary invariants.
2003  * Currently this includes the sorting of all supplemental gids.
2004  * crextend() must have been called before hand to ensure sufficient
2005  * space is available.
2006  */
2007 static void
2008 crsetgroups_locked(struct ucred *cr, int ngrp, gid_t *groups)
2009 {
2010         int i;
2011         int j;
2012         gid_t g;
2013
2014         KASSERT(cr->cr_agroups >= ngrp, ("cr_ngroups is too small"));
2015
2016         bcopy(groups, cr->cr_groups, ngrp * sizeof(gid_t));
2017         cr->cr_ngroups = ngrp;
2018
2019         /*
2020          * Sort all groups except cr_groups[0] to allow groupmember to
2021          * perform a binary search.
2022          *
2023          * XXX: If large numbers of groups become common this should
2024          * be replaced with shell sort like linux uses or possibly
2025          * heap sort.
2026          */
2027         for (i = 2; i < ngrp; i++) {
2028                 g = cr->cr_groups[i];
2029                 for (j = i-1; j >= 1 && g < cr->cr_groups[j]; j--)
2030                         cr->cr_groups[j + 1] = cr->cr_groups[j];
2031                 cr->cr_groups[j + 1] = g;
2032         }
2033 }
2034
2035 /*
2036  * Copy groups in to a credential after expanding it if required.
2037  * Truncate the list to (ngroups_max + 1) if it is too large.
2038  */
2039 void
2040 crsetgroups(struct ucred *cr, int ngrp, gid_t *groups)
2041 {
2042
2043         if (ngrp > ngroups_max + 1)
2044                 ngrp = ngroups_max + 1;
2045
2046         crextend(cr, ngrp);
2047         crsetgroups_locked(cr, ngrp, groups);
2048 }
2049
2050 /*
2051  * Get login name, if available.
2052  */
2053 #ifndef _SYS_SYSPROTO_H_
2054 struct getlogin_args {
2055         char    *namebuf;
2056         u_int   namelen;
2057 };
2058 #endif
2059 /* ARGSUSED */
2060 int
2061 sys_getlogin(struct thread *td, struct getlogin_args *uap)
2062 {
2063         char login[MAXLOGNAME];
2064         struct proc *p = td->td_proc;
2065         size_t len;
2066
2067         if (uap->namelen > MAXLOGNAME)
2068                 uap->namelen = MAXLOGNAME;
2069         PROC_LOCK(p);
2070         SESS_LOCK(p->p_session);
2071         len = strlcpy(login, p->p_session->s_login, uap->namelen) + 1;
2072         SESS_UNLOCK(p->p_session);
2073         PROC_UNLOCK(p);
2074         if (len > uap->namelen)
2075                 return (ERANGE);
2076         return (copyout(login, uap->namebuf, len));
2077 }
2078
2079 /*
2080  * Set login name.
2081  */
2082 #ifndef _SYS_SYSPROTO_H_
2083 struct setlogin_args {
2084         char    *namebuf;
2085 };
2086 #endif
2087 /* ARGSUSED */
2088 int
2089 sys_setlogin(struct thread *td, struct setlogin_args *uap)
2090 {
2091         struct proc *p = td->td_proc;
2092         int error;
2093         char logintmp[MAXLOGNAME];
2094
2095         CTASSERT(sizeof(p->p_session->s_login) >= sizeof(logintmp));
2096
2097         error = priv_check(td, PRIV_PROC_SETLOGIN);
2098         if (error)
2099                 return (error);
2100         error = copyinstr(uap->namebuf, logintmp, sizeof(logintmp), NULL);
2101         if (error != 0) {
2102                 if (error == ENAMETOOLONG)
2103                         error = EINVAL;
2104                 return (error);
2105         }
2106         AUDIT_ARG_LOGIN(logintmp);
2107         PROC_LOCK(p);
2108         SESS_LOCK(p->p_session);
2109         strcpy(p->p_session->s_login, logintmp);
2110         SESS_UNLOCK(p->p_session);
2111         PROC_UNLOCK(p);
2112         return (0);
2113 }
2114
2115 void
2116 setsugid(struct proc *p)
2117 {
2118
2119         PROC_LOCK_ASSERT(p, MA_OWNED);
2120         p->p_flag |= P_SUGID;
2121         if (!(p->p_pfsflags & PF_ISUGID))
2122                 p->p_stops = 0;
2123 }
2124
2125 /*-
2126  * Change a process's effective uid.
2127  * Side effects: newcred->cr_uid and newcred->cr_uidinfo will be modified.
2128  * References: newcred must be an exclusive credential reference for the
2129  *             duration of the call.
2130  */
2131 void
2132 change_euid(struct ucred *newcred, struct uidinfo *euip)
2133 {
2134
2135         newcred->cr_uid = euip->ui_uid;
2136         uihold(euip);
2137         uifree(newcred->cr_uidinfo);
2138         newcred->cr_uidinfo = euip;
2139 }
2140
2141 /*-
2142  * Change a process's effective gid.
2143  * Side effects: newcred->cr_gid will be modified.
2144  * References: newcred must be an exclusive credential reference for the
2145  *             duration of the call.
2146  */
2147 void
2148 change_egid(struct ucred *newcred, gid_t egid)
2149 {
2150
2151         newcred->cr_groups[0] = egid;
2152 }
2153
2154 /*-
2155  * Change a process's real uid.
2156  * Side effects: newcred->cr_ruid will be updated, newcred->cr_ruidinfo
2157  *               will be updated, and the old and new cr_ruidinfo proc
2158  *               counts will be updated.
2159  * References: newcred must be an exclusive credential reference for the
2160  *             duration of the call.
2161  */
2162 void
2163 change_ruid(struct ucred *newcred, struct uidinfo *ruip)
2164 {
2165
2166         (void)chgproccnt(newcred->cr_ruidinfo, -1, 0);
2167         newcred->cr_ruid = ruip->ui_uid;
2168         uihold(ruip);
2169         uifree(newcred->cr_ruidinfo);
2170         newcred->cr_ruidinfo = ruip;
2171         (void)chgproccnt(newcred->cr_ruidinfo, 1, 0);
2172 }
2173
2174 /*-
2175  * Change a process's real gid.
2176  * Side effects: newcred->cr_rgid will be updated.
2177  * References: newcred must be an exclusive credential reference for the
2178  *             duration of the call.
2179  */
2180 void
2181 change_rgid(struct ucred *newcred, gid_t rgid)
2182 {
2183
2184         newcred->cr_rgid = rgid;
2185 }
2186
2187 /*-
2188  * Change a process's saved uid.
2189  * Side effects: newcred->cr_svuid will be updated.
2190  * References: newcred must be an exclusive credential reference for the
2191  *             duration of the call.
2192  */
2193 void
2194 change_svuid(struct ucred *newcred, uid_t svuid)
2195 {
2196
2197         newcred->cr_svuid = svuid;
2198 }
2199
2200 /*-
2201  * Change a process's saved gid.
2202  * Side effects: newcred->cr_svgid will be updated.
2203  * References: newcred must be an exclusive credential reference for the
2204  *             duration of the call.
2205  */
2206 void
2207 change_svgid(struct ucred *newcred, gid_t svgid)
2208 {
2209
2210         newcred->cr_svgid = svgid;
2211 }