17c478bd9Sstevel@tonic-gate /*
27c478bd9Sstevel@tonic-gate * CDDL HEADER START
37c478bd9Sstevel@tonic-gate *
47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the
545916cd2Sjpk * Common Development and Distribution License (the "License").
645916cd2Sjpk * You may not use this file except in compliance with the License.
77c478bd9Sstevel@tonic-gate *
87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing.
107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions
117c478bd9Sstevel@tonic-gate * and limitations under the License.
127c478bd9Sstevel@tonic-gate *
137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each
147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the
167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying
177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner]
187c478bd9Sstevel@tonic-gate *
197c478bd9Sstevel@tonic-gate * CDDL HEADER END
207c478bd9Sstevel@tonic-gate */
21b77dfcc8SIra Cooper /*
22b77dfcc8SIra Cooper * Copyright (c) 2013, Ira Cooper. All rights reserved.
23*526073d8SMatt Barden * Copyright 2020 Nexenta by DDN, Inc. All rights reserved.
24b77dfcc8SIra Cooper */
257c478bd9Sstevel@tonic-gate /*
26134a1f4eSCasper H.S. Dik * Copyright (c) 1989, 2010, Oracle and/or its affiliates. All rights reserved.
277c478bd9Sstevel@tonic-gate */
287c478bd9Sstevel@tonic-gate
297c478bd9Sstevel@tonic-gate /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
30*526073d8SMatt Barden /* All Rights Reserved */
317c478bd9Sstevel@tonic-gate
327c478bd9Sstevel@tonic-gate /*
337c478bd9Sstevel@tonic-gate * University Copyright- Copyright (c) 1982, 1986, 1988
347c478bd9Sstevel@tonic-gate * The Regents of the University of California
357c478bd9Sstevel@tonic-gate * All Rights Reserved
367c478bd9Sstevel@tonic-gate *
377c478bd9Sstevel@tonic-gate * University Acknowledgment- Portions of this document are derived from
387c478bd9Sstevel@tonic-gate * software developed by the University of California, Berkeley, and its
397c478bd9Sstevel@tonic-gate * contributors.
407c478bd9Sstevel@tonic-gate */
417c478bd9Sstevel@tonic-gate
427c478bd9Sstevel@tonic-gate #include <sys/types.h>
437c478bd9Sstevel@tonic-gate #include <sys/sysmacros.h>
447c478bd9Sstevel@tonic-gate #include <sys/param.h>
457c478bd9Sstevel@tonic-gate #include <sys/systm.h>
467c478bd9Sstevel@tonic-gate #include <sys/cred_impl.h>
477c478bd9Sstevel@tonic-gate #include <sys/policy.h>
487c478bd9Sstevel@tonic-gate #include <sys/vnode.h>
497c478bd9Sstevel@tonic-gate #include <sys/errno.h>
507c478bd9Sstevel@tonic-gate #include <sys/kmem.h>
517c478bd9Sstevel@tonic-gate #include <sys/user.h>
527c478bd9Sstevel@tonic-gate #include <sys/proc.h>
537c478bd9Sstevel@tonic-gate #include <sys/syscall.h>
547c478bd9Sstevel@tonic-gate #include <sys/debug.h>
557c478bd9Sstevel@tonic-gate #include <sys/atomic.h>
567c478bd9Sstevel@tonic-gate #include <sys/ucred.h>
577c478bd9Sstevel@tonic-gate #include <sys/prsystm.h>
587c478bd9Sstevel@tonic-gate #include <sys/modctl.h>
59f48205beScasper #include <sys/avl.h>
60da6c28aaSamw #include <sys/door.h>
617c478bd9Sstevel@tonic-gate #include <c2/audit.h>
627c478bd9Sstevel@tonic-gate #include <sys/zone.h>
6345916cd2Sjpk #include <sys/tsol/label.h>
64f48205beScasper #include <sys/sid.h>
65c5c4113dSnw #include <sys/idmap.h>
66ddf7fe95Scasper #include <sys/klpd.h>
67da6c28aaSamw #include <sys/varargs.h>
68005d3febSMarek Pospisil #include <sys/sysconf.h>
6967dbe2beSCasper H.S. Dik #include <util/qsort.h>
70f48205beScasper
71bda89588Sjp
72bda89588Sjp /* Ephemeral IDs Zones specific data */
73bda89588Sjp typedef struct ephemeral_zsd {
74bda89588Sjp uid_t min_uid;
75bda89588Sjp uid_t last_uid;
76bda89588Sjp gid_t min_gid;
77bda89588Sjp gid_t last_gid;
78f48205beScasper kmutex_t eph_lock;
79bda89588Sjp cred_t *eph_nobody;
80bda89588Sjp } ephemeral_zsd_t;
81bda89588Sjp
8267dbe2beSCasper H.S. Dik static void crgrphold(credgrp_t *);
8367dbe2beSCasper H.S. Dik
8467dbe2beSCasper H.S. Dik #define CREDGRPSZ(ngrp) (sizeof (credgrp_t) + ((ngrp - 1) * sizeof (gid_t)))
85bda89588Sjp
86bda89588Sjp static kmutex_t ephemeral_zone_mutex;
87bda89588Sjp static zone_key_t ephemeral_zone_key;
887c478bd9Sstevel@tonic-gate
897c478bd9Sstevel@tonic-gate static struct kmem_cache *cred_cache;
90bda89588Sjp static size_t crsize = 0;
91bda89588Sjp static int audoff = 0;
92bda89588Sjp uint32_t ucredsize;
93bda89588Sjp cred_t *kcred;
94bda89588Sjp static cred_t *dummycr;
957c478bd9Sstevel@tonic-gate
967c478bd9Sstevel@tonic-gate int rstlink; /* link(2) restricted to files owned by user? */
977c478bd9Sstevel@tonic-gate
987c478bd9Sstevel@tonic-gate static int get_c2audit_load(void);
997c478bd9Sstevel@tonic-gate
1007c478bd9Sstevel@tonic-gate #define CR_AUINFO(c) (auditinfo_addr_t *)((audoff == 0) ? NULL : \
1017c478bd9Sstevel@tonic-gate ((char *)(c)) + audoff)
1027c478bd9Sstevel@tonic-gate
10345916cd2Sjpk #define REMOTE_PEER_CRED(c) ((c)->cr_gid == -1)
1047c478bd9Sstevel@tonic-gate
10567dbe2beSCasper H.S. Dik #define BIN_GROUP_SEARCH_CUTOFF 16
106bda89588Sjp
107bda89588Sjp static boolean_t hasephids = B_FALSE;
108bda89588Sjp
109bda89588Sjp static ephemeral_zsd_t *
get_ephemeral_zsd(zone_t * zone)110bda89588Sjp get_ephemeral_zsd(zone_t *zone)
111bda89588Sjp {
112bda89588Sjp ephemeral_zsd_t *eph_zsd;
113bda89588Sjp
114bda89588Sjp eph_zsd = zone_getspecific(ephemeral_zone_key, zone);
115bda89588Sjp if (eph_zsd != NULL) {
116bda89588Sjp return (eph_zsd);
117bda89588Sjp }
118bda89588Sjp
119bda89588Sjp mutex_enter(&ephemeral_zone_mutex);
120bda89588Sjp eph_zsd = zone_getspecific(ephemeral_zone_key, zone);
121bda89588Sjp if (eph_zsd == NULL) {
122bda89588Sjp eph_zsd = kmem_zalloc(sizeof (ephemeral_zsd_t), KM_SLEEP);
123bda89588Sjp eph_zsd->min_uid = MAXUID;
124bda89588Sjp eph_zsd->last_uid = IDMAP_WK__MAX_UID;
125bda89588Sjp eph_zsd->min_gid = MAXUID;
126bda89588Sjp eph_zsd->last_gid = IDMAP_WK__MAX_GID;
127bda89588Sjp mutex_init(&eph_zsd->eph_lock, NULL, MUTEX_DEFAULT, NULL);
128bda89588Sjp
129bda89588Sjp /*
130bda89588Sjp * nobody is used to map SID containing CRs.
131bda89588Sjp */
132bda89588Sjp eph_zsd->eph_nobody = crdup(zone->zone_kcred);
133bda89588Sjp (void) crsetugid(eph_zsd->eph_nobody, UID_NOBODY, GID_NOBODY);
134bda89588Sjp CR_FLAGS(eph_zsd->eph_nobody) = 0;
135bda89588Sjp eph_zsd->eph_nobody->cr_zone = zone;
136bda89588Sjp
137bda89588Sjp (void) zone_setspecific(ephemeral_zone_key, zone, eph_zsd);
138bda89588Sjp }
139bda89588Sjp mutex_exit(&ephemeral_zone_mutex);
140bda89588Sjp return (eph_zsd);
141bda89588Sjp }
142bda89588Sjp
1435f9878b0Sken Powell - Sun Microsystem static cred_t *crdup_flags(const cred_t *, int);
144ddf7fe95Scasper static cred_t *cralloc_flags(int);
145ddf7fe95Scasper
146f48205beScasper /*
147bda89588Sjp * This function is called when a zone is destroyed
148f48205beScasper */
149bda89588Sjp static void
150bda89588Sjp /* ARGSUSED */
destroy_ephemeral_zsd(zoneid_t zone_id,void * arg)151bda89588Sjp destroy_ephemeral_zsd(zoneid_t zone_id, void *arg)
152bda89588Sjp {
153bda89588Sjp ephemeral_zsd_t *eph_zsd = arg;
154bda89588Sjp if (eph_zsd != NULL) {
155bda89588Sjp mutex_destroy(&eph_zsd->eph_lock);
156bda89588Sjp crfree(eph_zsd->eph_nobody);
157bda89588Sjp kmem_free(eph_zsd, sizeof (ephemeral_zsd_t));
158bda89588Sjp }
159bda89588Sjp }
160bda89588Sjp
161f48205beScasper
162f48205beScasper
1637c478bd9Sstevel@tonic-gate /*
1647c478bd9Sstevel@tonic-gate * Initialize credentials data structures.
1657c478bd9Sstevel@tonic-gate */
1667c478bd9Sstevel@tonic-gate
1677c478bd9Sstevel@tonic-gate void
cred_init(void)1687c478bd9Sstevel@tonic-gate cred_init(void)
1697c478bd9Sstevel@tonic-gate {
1707c478bd9Sstevel@tonic-gate priv_init();
1717c478bd9Sstevel@tonic-gate
17267dbe2beSCasper H.S. Dik crsize = sizeof (cred_t);
1737c478bd9Sstevel@tonic-gate
1747c478bd9Sstevel@tonic-gate if (get_c2audit_load() > 0) {
1757c478bd9Sstevel@tonic-gate #ifdef _LP64
1767c478bd9Sstevel@tonic-gate /* assure audit context is 64-bit aligned */
1777c478bd9Sstevel@tonic-gate audoff = (crsize +
1787c478bd9Sstevel@tonic-gate sizeof (int64_t) - 1) & ~(sizeof (int64_t) - 1);
1797c478bd9Sstevel@tonic-gate #else /* _LP64 */
1807c478bd9Sstevel@tonic-gate audoff = crsize;
1817c478bd9Sstevel@tonic-gate #endif /* _LP64 */
1827c478bd9Sstevel@tonic-gate crsize = audoff + sizeof (auditinfo_addr_t);
1837c478bd9Sstevel@tonic-gate crsize = (crsize + sizeof (int) - 1) & ~(sizeof (int) - 1);
1847c478bd9Sstevel@tonic-gate }
1857c478bd9Sstevel@tonic-gate
1867c478bd9Sstevel@tonic-gate cred_cache = kmem_cache_create("cred_cache", crsize, 0,
187c5c4113dSnw NULL, NULL, NULL, NULL, NULL, 0);
1887c478bd9Sstevel@tonic-gate
18945916cd2Sjpk /*
19045916cd2Sjpk * dummycr is used to copy initial state for creds.
19145916cd2Sjpk */
19245916cd2Sjpk dummycr = cralloc();
19345916cd2Sjpk bzero(dummycr, crsize);
19445916cd2Sjpk dummycr->cr_ref = 1;
195f48205beScasper dummycr->cr_uid = (uid_t)-1;
196f48205beScasper dummycr->cr_gid = (gid_t)-1;
197f48205beScasper dummycr->cr_ruid = (uid_t)-1;
198f48205beScasper dummycr->cr_rgid = (gid_t)-1;
199f48205beScasper dummycr->cr_suid = (uid_t)-1;
200f48205beScasper dummycr->cr_sgid = (gid_t)-1;
201f48205beScasper
20245916cd2Sjpk
2037c478bd9Sstevel@tonic-gate /*
2047c478bd9Sstevel@tonic-gate * kcred is used by anything that needs all privileges; it's
2057c478bd9Sstevel@tonic-gate * also the template used for crget as it has all the compatible
2067c478bd9Sstevel@tonic-gate * sets filled in.
2077c478bd9Sstevel@tonic-gate */
2087c478bd9Sstevel@tonic-gate kcred = cralloc();
2097c478bd9Sstevel@tonic-gate
2107c478bd9Sstevel@tonic-gate bzero(kcred, crsize);
2117c478bd9Sstevel@tonic-gate kcred->cr_ref = 1;
2127c478bd9Sstevel@tonic-gate
2137c478bd9Sstevel@tonic-gate /* kcred is never freed, so we don't need zone_cred_hold here */
2147c478bd9Sstevel@tonic-gate kcred->cr_zone = &zone0;
2157c478bd9Sstevel@tonic-gate
2167c478bd9Sstevel@tonic-gate priv_fillset(&CR_LPRIV(kcred));
2177c478bd9Sstevel@tonic-gate CR_IPRIV(kcred) = *priv_basic;
2187c478bd9Sstevel@tonic-gate
219d2a70789SRichard Lowe priv_addset(&CR_IPRIV(kcred), PRIV_PROC_SECFLAGS);
220d2a70789SRichard Lowe
2217c478bd9Sstevel@tonic-gate /* Not a basic privilege, if chown is not restricted add it to I0 */
2227c478bd9Sstevel@tonic-gate if (!rstchown)
2237c478bd9Sstevel@tonic-gate priv_addset(&CR_IPRIV(kcred), PRIV_FILE_CHOWN_SELF);
2247c478bd9Sstevel@tonic-gate
2257c478bd9Sstevel@tonic-gate /* Basic privilege, if link is restricted remove it from I0 */
2267c478bd9Sstevel@tonic-gate if (rstlink)
2277c478bd9Sstevel@tonic-gate priv_delset(&CR_IPRIV(kcred), PRIV_FILE_LINK_ANY);
2287c478bd9Sstevel@tonic-gate
2297c478bd9Sstevel@tonic-gate CR_EPRIV(kcred) = CR_PPRIV(kcred) = CR_IPRIV(kcred);
23045916cd2Sjpk
23145916cd2Sjpk CR_FLAGS(kcred) = NET_MAC_AWARE;
2327c478bd9Sstevel@tonic-gate
2337c478bd9Sstevel@tonic-gate /*
2347c478bd9Sstevel@tonic-gate * Set up credentials of p0.
2357c478bd9Sstevel@tonic-gate */
2367c478bd9Sstevel@tonic-gate ttoproc(curthread)->p_cred = kcred;
2377c478bd9Sstevel@tonic-gate curthread->t_cred = kcred;
2387c478bd9Sstevel@tonic-gate
2397c478bd9Sstevel@tonic-gate ucredsize = UCRED_SIZE;
240bda89588Sjp
241bda89588Sjp mutex_init(&ephemeral_zone_mutex, NULL, MUTEX_DEFAULT, NULL);
242bda89588Sjp zone_key_create(&ephemeral_zone_key, NULL, NULL, destroy_ephemeral_zsd);
2437c478bd9Sstevel@tonic-gate }
2447c478bd9Sstevel@tonic-gate
2457c478bd9Sstevel@tonic-gate /*
2467c478bd9Sstevel@tonic-gate * Allocate (nearly) uninitialized cred_t.
2477c478bd9Sstevel@tonic-gate */
248ddf7fe95Scasper static cred_t *
cralloc_flags(int flgs)249ddf7fe95Scasper cralloc_flags(int flgs)
2507c478bd9Sstevel@tonic-gate {
251ddf7fe95Scasper cred_t *cr = kmem_cache_alloc(cred_cache, flgs);
252ddf7fe95Scasper
253ddf7fe95Scasper if (cr == NULL)
254ddf7fe95Scasper return (NULL);
255ddf7fe95Scasper
2567c478bd9Sstevel@tonic-gate cr->cr_ref = 1; /* So we can crfree() */
2577c478bd9Sstevel@tonic-gate cr->cr_zone = NULL;
25845916cd2Sjpk cr->cr_label = NULL;
259f48205beScasper cr->cr_ksid = NULL;
260ddf7fe95Scasper cr->cr_klpd = NULL;
26167dbe2beSCasper H.S. Dik cr->cr_grps = NULL;
262f48205beScasper return (cr);
263f48205beScasper }
264f48205beScasper
265ddf7fe95Scasper cred_t *
cralloc(void)266ddf7fe95Scasper cralloc(void)
267ddf7fe95Scasper {
268ddf7fe95Scasper return (cralloc_flags(KM_SLEEP));
269ddf7fe95Scasper }
270ddf7fe95Scasper
271f48205beScasper /*
272f48205beScasper * As cralloc but prepared for ksid change (if appropriate).
273f48205beScasper */
274f48205beScasper cred_t *
cralloc_ksid(void)275f48205beScasper cralloc_ksid(void)
276f48205beScasper {
277f48205beScasper cred_t *cr = cralloc();
278f48205beScasper if (hasephids)
279f48205beScasper cr->cr_ksid = kcrsid_alloc();
2807c478bd9Sstevel@tonic-gate return (cr);
2817c478bd9Sstevel@tonic-gate }
2827c478bd9Sstevel@tonic-gate
2837c478bd9Sstevel@tonic-gate /*
2847c478bd9Sstevel@tonic-gate * Allocate a initialized cred structure and crhold() it.
2857c478bd9Sstevel@tonic-gate * Initialized means: all ids 0, group count 0, L=Full, E=P=I=I0
2867c478bd9Sstevel@tonic-gate */
2877c478bd9Sstevel@tonic-gate cred_t *
crget(void)2887c478bd9Sstevel@tonic-gate crget(void)
2897c478bd9Sstevel@tonic-gate {
2907c478bd9Sstevel@tonic-gate cred_t *cr = kmem_cache_alloc(cred_cache, KM_SLEEP);
2917c478bd9Sstevel@tonic-gate
292*526073d8SMatt Barden bcopy(zone_kcred(), cr, crsize);
2937c478bd9Sstevel@tonic-gate cr->cr_ref = 1;
2947c478bd9Sstevel@tonic-gate zone_cred_hold(cr->cr_zone);
29545916cd2Sjpk if (cr->cr_label)
29645916cd2Sjpk label_hold(cr->cr_label);
297ddf7fe95Scasper ASSERT(cr->cr_klpd == NULL);
29867dbe2beSCasper H.S. Dik ASSERT(cr->cr_grps == NULL);
2997c478bd9Sstevel@tonic-gate return (cr);
3007c478bd9Sstevel@tonic-gate }
3017c478bd9Sstevel@tonic-gate
3027c478bd9Sstevel@tonic-gate /*
3037c478bd9Sstevel@tonic-gate * Broadcast the cred to all the threads in the process.
3047c478bd9Sstevel@tonic-gate * The current thread's credentials can be set right away, but other
3057c478bd9Sstevel@tonic-gate * threads must wait until the start of the next system call or trap.
3067c478bd9Sstevel@tonic-gate * This avoids changing the cred in the middle of a system call.
3077c478bd9Sstevel@tonic-gate *
3087c478bd9Sstevel@tonic-gate * The cred has already been held for the process and the thread (2 holds),
3097c478bd9Sstevel@tonic-gate * and p->p_cred set.
3107c478bd9Sstevel@tonic-gate *
3117c478bd9Sstevel@tonic-gate * p->p_crlock shouldn't be held here, since p_lock must be acquired.
3127c478bd9Sstevel@tonic-gate */
3137c478bd9Sstevel@tonic-gate void
crset(proc_t * p,cred_t * cr)3147c478bd9Sstevel@tonic-gate crset(proc_t *p, cred_t *cr)
3157c478bd9Sstevel@tonic-gate {
3167c478bd9Sstevel@tonic-gate kthread_id_t t;
3177c478bd9Sstevel@tonic-gate kthread_id_t first;
3187c478bd9Sstevel@tonic-gate cred_t *oldcr;
3197c478bd9Sstevel@tonic-gate
3207c478bd9Sstevel@tonic-gate ASSERT(p == curproc); /* assumes p_lwpcnt can't change */
3217c478bd9Sstevel@tonic-gate
3227c478bd9Sstevel@tonic-gate /*
3237c478bd9Sstevel@tonic-gate * DTrace accesses t_cred in probe context. t_cred must always be
3247c478bd9Sstevel@tonic-gate * either NULL, or point to a valid, allocated cred structure.
3257c478bd9Sstevel@tonic-gate */
3267c478bd9Sstevel@tonic-gate t = curthread;
3277c478bd9Sstevel@tonic-gate oldcr = t->t_cred;
3287c478bd9Sstevel@tonic-gate t->t_cred = cr; /* the cred is held by caller for this thread */
3297c478bd9Sstevel@tonic-gate crfree(oldcr); /* free the old cred for the thread */
3307c478bd9Sstevel@tonic-gate
3317c478bd9Sstevel@tonic-gate /*
3327c478bd9Sstevel@tonic-gate * Broadcast to other threads, if any.
3337c478bd9Sstevel@tonic-gate */
3347c478bd9Sstevel@tonic-gate if (p->p_lwpcnt > 1) {
3357c478bd9Sstevel@tonic-gate mutex_enter(&p->p_lock); /* to keep thread list safe */
3367c478bd9Sstevel@tonic-gate first = curthread;
3377c478bd9Sstevel@tonic-gate for (t = first->t_forw; t != first; t = t->t_forw)
3387c478bd9Sstevel@tonic-gate t->t_pre_sys = 1; /* so syscall will get new cred */
3397c478bd9Sstevel@tonic-gate mutex_exit(&p->p_lock);
3407c478bd9Sstevel@tonic-gate }
3417c478bd9Sstevel@tonic-gate }
3427c478bd9Sstevel@tonic-gate
3437c478bd9Sstevel@tonic-gate /*
3447c478bd9Sstevel@tonic-gate * Put a hold on a cred structure.
3457c478bd9Sstevel@tonic-gate */
3467c478bd9Sstevel@tonic-gate void
crhold(cred_t * cr)3477c478bd9Sstevel@tonic-gate crhold(cred_t *cr)
3487c478bd9Sstevel@tonic-gate {
349134a1f4eSCasper H.S. Dik ASSERT(cr->cr_ref != 0xdeadbeef && cr->cr_ref != 0);
3501a5e258fSJosef 'Jeff' Sipek atomic_inc_32(&cr->cr_ref);
3517c478bd9Sstevel@tonic-gate }
3527c478bd9Sstevel@tonic-gate
3537c478bd9Sstevel@tonic-gate /*
3547c478bd9Sstevel@tonic-gate * Release previous hold on a cred structure. Free it if refcnt == 0.
35545916cd2Sjpk * If cred uses label different from zone label, free it.
3567c478bd9Sstevel@tonic-gate */
3577c478bd9Sstevel@tonic-gate void
crfree(cred_t * cr)3587c478bd9Sstevel@tonic-gate crfree(cred_t *cr)
3597c478bd9Sstevel@tonic-gate {
360134a1f4eSCasper H.S. Dik ASSERT(cr->cr_ref != 0xdeadbeef && cr->cr_ref != 0);
3611a5e258fSJosef 'Jeff' Sipek if (atomic_dec_32_nv(&cr->cr_ref) == 0) {
3627c478bd9Sstevel@tonic-gate ASSERT(cr != kcred);
36345916cd2Sjpk if (cr->cr_label)
36445916cd2Sjpk label_rele(cr->cr_label);
365ddf7fe95Scasper if (cr->cr_klpd)
366ddf7fe95Scasper crklpd_rele(cr->cr_klpd);
3677c478bd9Sstevel@tonic-gate if (cr->cr_zone)
3687c478bd9Sstevel@tonic-gate zone_cred_rele(cr->cr_zone);
369f48205beScasper if (cr->cr_ksid)
370f48205beScasper kcrsid_rele(cr->cr_ksid);
37167dbe2beSCasper H.S. Dik if (cr->cr_grps)
37267dbe2beSCasper H.S. Dik crgrprele(cr->cr_grps);
37367dbe2beSCasper H.S. Dik
3747c478bd9Sstevel@tonic-gate kmem_cache_free(cred_cache, cr);
3757c478bd9Sstevel@tonic-gate }
3767c478bd9Sstevel@tonic-gate }
3777c478bd9Sstevel@tonic-gate
3787c478bd9Sstevel@tonic-gate /*
3797c478bd9Sstevel@tonic-gate * Copy a cred structure to a new one and free the old one.
3807c478bd9Sstevel@tonic-gate * The new cred will have two references. One for the calling process,
381*526073d8SMatt Barden * and one for the thread.
3827c478bd9Sstevel@tonic-gate */
3837c478bd9Sstevel@tonic-gate cred_t *
crcopy(cred_t * cr)3847c478bd9Sstevel@tonic-gate crcopy(cred_t *cr)
3857c478bd9Sstevel@tonic-gate {
3867c478bd9Sstevel@tonic-gate cred_t *newcr;
3877c478bd9Sstevel@tonic-gate
3887c478bd9Sstevel@tonic-gate newcr = cralloc();
3897c478bd9Sstevel@tonic-gate bcopy(cr, newcr, crsize);
3907c478bd9Sstevel@tonic-gate if (newcr->cr_zone)
3917c478bd9Sstevel@tonic-gate zone_cred_hold(newcr->cr_zone);
39245916cd2Sjpk if (newcr->cr_label)
393ddf7fe95Scasper label_hold(newcr->cr_label);
394f48205beScasper if (newcr->cr_ksid)
395ddf7fe95Scasper kcrsid_hold(newcr->cr_ksid);
396ddf7fe95Scasper if (newcr->cr_klpd)
397ddf7fe95Scasper crklpd_hold(newcr->cr_klpd);
39867dbe2beSCasper H.S. Dik if (newcr->cr_grps)
39967dbe2beSCasper H.S. Dik crgrphold(newcr->cr_grps);
4007c478bd9Sstevel@tonic-gate crfree(cr);
4017c478bd9Sstevel@tonic-gate newcr->cr_ref = 2; /* caller gets two references */
4027c478bd9Sstevel@tonic-gate return (newcr);
4037c478bd9Sstevel@tonic-gate }
4047c478bd9Sstevel@tonic-gate
4057c478bd9Sstevel@tonic-gate /*
4067c478bd9Sstevel@tonic-gate * Copy a cred structure to a new one and free the old one.
4077c478bd9Sstevel@tonic-gate * The new cred will have two references. One for the calling process,
408*526073d8SMatt Barden * and one for the thread.
4097c478bd9Sstevel@tonic-gate * This variation on crcopy uses a pre-allocated structure for the
4107c478bd9Sstevel@tonic-gate * "new" cred.
4117c478bd9Sstevel@tonic-gate */
4127c478bd9Sstevel@tonic-gate void
crcopy_to(cred_t * oldcr,cred_t * newcr)4137c478bd9Sstevel@tonic-gate crcopy_to(cred_t *oldcr, cred_t *newcr)
4147c478bd9Sstevel@tonic-gate {
415f48205beScasper credsid_t *nkcr = newcr->cr_ksid;
416f48205beScasper
4177c478bd9Sstevel@tonic-gate bcopy(oldcr, newcr, crsize);
4187c478bd9Sstevel@tonic-gate if (newcr->cr_zone)
4197c478bd9Sstevel@tonic-gate zone_cred_hold(newcr->cr_zone);
42045916cd2Sjpk if (newcr->cr_label)
42145916cd2Sjpk label_hold(newcr->cr_label);
422ddf7fe95Scasper if (newcr->cr_klpd)
423ddf7fe95Scasper crklpd_hold(newcr->cr_klpd);
42467dbe2beSCasper H.S. Dik if (newcr->cr_grps)
42567dbe2beSCasper H.S. Dik crgrphold(newcr->cr_grps);
426f48205beScasper if (nkcr) {
427f48205beScasper newcr->cr_ksid = nkcr;
428f48205beScasper kcrsidcopy_to(oldcr->cr_ksid, newcr->cr_ksid);
429f48205beScasper } else if (newcr->cr_ksid)
430f48205beScasper kcrsid_hold(newcr->cr_ksid);
4317c478bd9Sstevel@tonic-gate crfree(oldcr);
4327c478bd9Sstevel@tonic-gate newcr->cr_ref = 2; /* caller gets two references */
4337c478bd9Sstevel@tonic-gate }
4347c478bd9Sstevel@tonic-gate
4357c478bd9Sstevel@tonic-gate /*
4367c478bd9Sstevel@tonic-gate * Dup a cred struct to a new held one.
4377c478bd9Sstevel@tonic-gate * The old cred is not freed.
4387c478bd9Sstevel@tonic-gate */
439ddf7fe95Scasper static cred_t *
crdup_flags(const cred_t * cr,int flgs)4405f9878b0Sken Powell - Sun Microsystem crdup_flags(const cred_t *cr, int flgs)
4417c478bd9Sstevel@tonic-gate {
4427c478bd9Sstevel@tonic-gate cred_t *newcr;
4437c478bd9Sstevel@tonic-gate
444ddf7fe95Scasper newcr = cralloc_flags(flgs);
445ddf7fe95Scasper
446ddf7fe95Scasper if (newcr == NULL)
447ddf7fe95Scasper return (NULL);
448ddf7fe95Scasper
4497c478bd9Sstevel@tonic-gate bcopy(cr, newcr, crsize);
4507c478bd9Sstevel@tonic-gate if (newcr->cr_zone)
4517c478bd9Sstevel@tonic-gate zone_cred_hold(newcr->cr_zone);
45245916cd2Sjpk if (newcr->cr_label)
45345916cd2Sjpk label_hold(newcr->cr_label);
454ddf7fe95Scasper if (newcr->cr_klpd)
455ddf7fe95Scasper crklpd_hold(newcr->cr_klpd);
456f48205beScasper if (newcr->cr_ksid)
457f48205beScasper kcrsid_hold(newcr->cr_ksid);
45867dbe2beSCasper H.S. Dik if (newcr->cr_grps)
45967dbe2beSCasper H.S. Dik crgrphold(newcr->cr_grps);
4607c478bd9Sstevel@tonic-gate newcr->cr_ref = 1;
4617c478bd9Sstevel@tonic-gate return (newcr);
4627c478bd9Sstevel@tonic-gate }
4637c478bd9Sstevel@tonic-gate
464ddf7fe95Scasper cred_t *
crdup(cred_t * cr)465ddf7fe95Scasper crdup(cred_t *cr)
466ddf7fe95Scasper {
467ddf7fe95Scasper return (crdup_flags(cr, KM_SLEEP));
468ddf7fe95Scasper }
469ddf7fe95Scasper
4707c478bd9Sstevel@tonic-gate /*
4717c478bd9Sstevel@tonic-gate * Dup a cred struct to a new held one.
4727c478bd9Sstevel@tonic-gate * The old cred is not freed.
4737c478bd9Sstevel@tonic-gate * This variation on crdup uses a pre-allocated structure for the
4747c478bd9Sstevel@tonic-gate * "new" cred.
4757c478bd9Sstevel@tonic-gate */
4767c478bd9Sstevel@tonic-gate void
crdup_to(cred_t * oldcr,cred_t * newcr)4777c478bd9Sstevel@tonic-gate crdup_to(cred_t *oldcr, cred_t *newcr)
4787c478bd9Sstevel@tonic-gate {
479f48205beScasper credsid_t *nkcr = newcr->cr_ksid;
480f48205beScasper
4817c478bd9Sstevel@tonic-gate bcopy(oldcr, newcr, crsize);
4827c478bd9Sstevel@tonic-gate if (newcr->cr_zone)
4837c478bd9Sstevel@tonic-gate zone_cred_hold(newcr->cr_zone);
48445916cd2Sjpk if (newcr->cr_label)
48545916cd2Sjpk label_hold(newcr->cr_label);
486ddf7fe95Scasper if (newcr->cr_klpd)
487ddf7fe95Scasper crklpd_hold(newcr->cr_klpd);
48867dbe2beSCasper H.S. Dik if (newcr->cr_grps)
48967dbe2beSCasper H.S. Dik crgrphold(newcr->cr_grps);
490f48205beScasper if (nkcr) {
491f48205beScasper newcr->cr_ksid = nkcr;
492f48205beScasper kcrsidcopy_to(oldcr->cr_ksid, newcr->cr_ksid);
493f48205beScasper } else if (newcr->cr_ksid)
494f48205beScasper kcrsid_hold(newcr->cr_ksid);
4957c478bd9Sstevel@tonic-gate newcr->cr_ref = 1;
4967c478bd9Sstevel@tonic-gate }
4977c478bd9Sstevel@tonic-gate
4987c478bd9Sstevel@tonic-gate /*
4997c478bd9Sstevel@tonic-gate * Return the (held) credentials for the current running process.
5007c478bd9Sstevel@tonic-gate */
5017c478bd9Sstevel@tonic-gate cred_t *
crgetcred(void)50245916cd2Sjpk crgetcred(void)
5037c478bd9Sstevel@tonic-gate {
5047c478bd9Sstevel@tonic-gate cred_t *cr;
5057c478bd9Sstevel@tonic-gate proc_t *p;
5067c478bd9Sstevel@tonic-gate
5077c478bd9Sstevel@tonic-gate p = ttoproc(curthread);
5087c478bd9Sstevel@tonic-gate mutex_enter(&p->p_crlock);
5097c478bd9Sstevel@tonic-gate crhold(cr = p->p_cred);
5107c478bd9Sstevel@tonic-gate mutex_exit(&p->p_crlock);
5117c478bd9Sstevel@tonic-gate return (cr);
5127c478bd9Sstevel@tonic-gate }
5137c478bd9Sstevel@tonic-gate
5147c478bd9Sstevel@tonic-gate /*
5157c478bd9Sstevel@tonic-gate * Backward compatibility check for suser().
5167c478bd9Sstevel@tonic-gate * Accounting flag is now set in the policy functions; auditing is
5177c478bd9Sstevel@tonic-gate * done through use of privilege in the audit trail.
5187c478bd9Sstevel@tonic-gate */
5197c478bd9Sstevel@tonic-gate int
suser(cred_t * cr)5207c478bd9Sstevel@tonic-gate suser(cred_t *cr)
5217c478bd9Sstevel@tonic-gate {
5227c478bd9Sstevel@tonic-gate return (PRIV_POLICY(cr, PRIV_SYS_SUSER_COMPAT, B_FALSE, EPERM, NULL)
5237c478bd9Sstevel@tonic-gate == 0);
5247c478bd9Sstevel@tonic-gate }
5257c478bd9Sstevel@tonic-gate
5267c478bd9Sstevel@tonic-gate /*
5277c478bd9Sstevel@tonic-gate * Determine whether the supplied group id is a member of the group
5287c478bd9Sstevel@tonic-gate * described by the supplied credentials.
5297c478bd9Sstevel@tonic-gate */
5307c478bd9Sstevel@tonic-gate int
groupmember(gid_t gid,const cred_t * cr)5317c478bd9Sstevel@tonic-gate groupmember(gid_t gid, const cred_t *cr)
5327c478bd9Sstevel@tonic-gate {
5337c478bd9Sstevel@tonic-gate if (gid == cr->cr_gid)
5347c478bd9Sstevel@tonic-gate return (1);
5357c478bd9Sstevel@tonic-gate return (supgroupmember(gid, cr));
5367c478bd9Sstevel@tonic-gate }
5377c478bd9Sstevel@tonic-gate
5387c478bd9Sstevel@tonic-gate /*
5397c478bd9Sstevel@tonic-gate * As groupmember but only check against the supplemental groups.
5407c478bd9Sstevel@tonic-gate */
5417c478bd9Sstevel@tonic-gate int
supgroupmember(gid_t gid,const cred_t * cr)5427c478bd9Sstevel@tonic-gate supgroupmember(gid_t gid, const cred_t *cr)
5437c478bd9Sstevel@tonic-gate {
54467dbe2beSCasper H.S. Dik int hi, lo;
54567dbe2beSCasper H.S. Dik credgrp_t *grps = cr->cr_grps;
5467c478bd9Sstevel@tonic-gate const gid_t *gp, *endgp;
5477c478bd9Sstevel@tonic-gate
54867dbe2beSCasper H.S. Dik if (grps == NULL)
54967dbe2beSCasper H.S. Dik return (0);
55067dbe2beSCasper H.S. Dik
55167dbe2beSCasper H.S. Dik /* For a small number of groups, use sequentials search. */
55267dbe2beSCasper H.S. Dik if (grps->crg_ngroups <= BIN_GROUP_SEARCH_CUTOFF) {
55367dbe2beSCasper H.S. Dik endgp = &grps->crg_groups[grps->crg_ngroups];
55467dbe2beSCasper H.S. Dik for (gp = grps->crg_groups; gp < endgp; gp++)
55567dbe2beSCasper H.S. Dik if (*gp == gid)
55667dbe2beSCasper H.S. Dik return (1);
55767dbe2beSCasper H.S. Dik return (0);
55867dbe2beSCasper H.S. Dik }
55967dbe2beSCasper H.S. Dik
56067dbe2beSCasper H.S. Dik /* We use binary search when we have many groups. */
56167dbe2beSCasper H.S. Dik lo = 0;
56267dbe2beSCasper H.S. Dik hi = grps->crg_ngroups - 1;
56367dbe2beSCasper H.S. Dik gp = grps->crg_groups;
56467dbe2beSCasper H.S. Dik
56567dbe2beSCasper H.S. Dik do {
56667dbe2beSCasper H.S. Dik int m = (lo + hi) / 2;
56767dbe2beSCasper H.S. Dik
56867dbe2beSCasper H.S. Dik if (gid > gp[m])
56967dbe2beSCasper H.S. Dik lo = m + 1;
57067dbe2beSCasper H.S. Dik else if (gid < gp[m])
57167dbe2beSCasper H.S. Dik hi = m - 1;
57267dbe2beSCasper H.S. Dik else
5737c478bd9Sstevel@tonic-gate return (1);
57467dbe2beSCasper H.S. Dik } while (lo <= hi);
57567dbe2beSCasper H.S. Dik
5767c478bd9Sstevel@tonic-gate return (0);
5777c478bd9Sstevel@tonic-gate }
5787c478bd9Sstevel@tonic-gate
5797c478bd9Sstevel@tonic-gate /*
5807c478bd9Sstevel@tonic-gate * This function is called to check whether the credentials set
5817c478bd9Sstevel@tonic-gate * "scrp" has permission to act on credentials set "tcrp". It enforces the
5827c478bd9Sstevel@tonic-gate * permission requirements needed to send a signal to a process.
5837c478bd9Sstevel@tonic-gate * The same requirements are imposed by other system calls, however.
5847c478bd9Sstevel@tonic-gate *
5857c478bd9Sstevel@tonic-gate * The rules are:
5867c478bd9Sstevel@tonic-gate * (1) if the credentials are the same, the check succeeds
5877c478bd9Sstevel@tonic-gate * (2) if the zone ids don't match, and scrp is not in the global zone or
5887c478bd9Sstevel@tonic-gate * does not have the PRIV_PROC_ZONE privilege, the check fails
5897c478bd9Sstevel@tonic-gate * (3) if the real or effective user id of scrp matches the real or saved
5907c478bd9Sstevel@tonic-gate * user id of tcrp or scrp has the PRIV_PROC_OWNER privilege, the check
5917c478bd9Sstevel@tonic-gate * succeeds
5927c478bd9Sstevel@tonic-gate * (4) otherwise, the check fails
5937c478bd9Sstevel@tonic-gate */
5947c478bd9Sstevel@tonic-gate int
hasprocperm(const cred_t * tcrp,const cred_t * scrp)5957c478bd9Sstevel@tonic-gate hasprocperm(const cred_t *tcrp, const cred_t *scrp)
5967c478bd9Sstevel@tonic-gate {
5977c478bd9Sstevel@tonic-gate if (scrp == tcrp)
5987c478bd9Sstevel@tonic-gate return (1);
5997c478bd9Sstevel@tonic-gate if (scrp->cr_zone != tcrp->cr_zone &&
6007c478bd9Sstevel@tonic-gate (scrp->cr_zone != global_zone ||
6017c478bd9Sstevel@tonic-gate secpolicy_proc_zone(scrp) != 0))
6027c478bd9Sstevel@tonic-gate return (0);
6037c478bd9Sstevel@tonic-gate if (scrp->cr_uid == tcrp->cr_ruid ||
6047c478bd9Sstevel@tonic-gate scrp->cr_ruid == tcrp->cr_ruid ||
6057c478bd9Sstevel@tonic-gate scrp->cr_uid == tcrp->cr_suid ||
6067c478bd9Sstevel@tonic-gate scrp->cr_ruid == tcrp->cr_suid ||
6077c478bd9Sstevel@tonic-gate !PRIV_POLICY(scrp, PRIV_PROC_OWNER, B_FALSE, EPERM, "hasprocperm"))
6087c478bd9Sstevel@tonic-gate return (1);
6097c478bd9Sstevel@tonic-gate return (0);
6107c478bd9Sstevel@tonic-gate }
6117c478bd9Sstevel@tonic-gate
6127c478bd9Sstevel@tonic-gate /*
6137c478bd9Sstevel@tonic-gate * This interface replaces hasprocperm; it works like hasprocperm but
6147c478bd9Sstevel@tonic-gate * additionally returns success if the proc_t's match
6157c478bd9Sstevel@tonic-gate * It is the preferred interface for most uses.
616ddf7fe95Scasper * And it will acquire p_crlock itself, so it assert's that it shouldn't
6177c478bd9Sstevel@tonic-gate * be held.
6187c478bd9Sstevel@tonic-gate */
6197c478bd9Sstevel@tonic-gate int
prochasprocperm(proc_t * tp,proc_t * sp,const cred_t * scrp)6207c478bd9Sstevel@tonic-gate prochasprocperm(proc_t *tp, proc_t *sp, const cred_t *scrp)
6217c478bd9Sstevel@tonic-gate {
6227c478bd9Sstevel@tonic-gate int rets;
6237c478bd9Sstevel@tonic-gate cred_t *tcrp;
6247c478bd9Sstevel@tonic-gate
6257c478bd9Sstevel@tonic-gate ASSERT(MUTEX_NOT_HELD(&tp->p_crlock));
6267c478bd9Sstevel@tonic-gate
6277c478bd9Sstevel@tonic-gate if (tp == sp)
6287c478bd9Sstevel@tonic-gate return (1);
6297c478bd9Sstevel@tonic-gate
6307c478bd9Sstevel@tonic-gate if (tp->p_sessp != sp->p_sessp && secpolicy_basic_proc(scrp) != 0)
6317c478bd9Sstevel@tonic-gate return (0);
6327c478bd9Sstevel@tonic-gate
6337c478bd9Sstevel@tonic-gate mutex_enter(&tp->p_crlock);
634ddf7fe95Scasper crhold(tcrp = tp->p_cred);
6357c478bd9Sstevel@tonic-gate mutex_exit(&tp->p_crlock);
636ddf7fe95Scasper rets = hasprocperm(tcrp, scrp);
637ddf7fe95Scasper crfree(tcrp);
6387c478bd9Sstevel@tonic-gate
6397c478bd9Sstevel@tonic-gate return (rets);
6407c478bd9Sstevel@tonic-gate }
6417c478bd9Sstevel@tonic-gate
6427c478bd9Sstevel@tonic-gate /*
6437c478bd9Sstevel@tonic-gate * This routine is used to compare two credentials to determine if
6447c478bd9Sstevel@tonic-gate * they refer to the same "user". If the pointers are equal, then
6457c478bd9Sstevel@tonic-gate * they must refer to the same user. Otherwise, the contents of
6467c478bd9Sstevel@tonic-gate * the credentials are compared to see whether they are equivalent.
6477c478bd9Sstevel@tonic-gate *
6487c478bd9Sstevel@tonic-gate * This routine returns 0 if the credentials refer to the same user,
6497c478bd9Sstevel@tonic-gate * 1 if they do not.
6507c478bd9Sstevel@tonic-gate */
6517c478bd9Sstevel@tonic-gate int
crcmp(const cred_t * cr1,const cred_t * cr2)6527c478bd9Sstevel@tonic-gate crcmp(const cred_t *cr1, const cred_t *cr2)
6537c478bd9Sstevel@tonic-gate {
65467dbe2beSCasper H.S. Dik credgrp_t *grp1, *grp2;
6557c478bd9Sstevel@tonic-gate
6567c478bd9Sstevel@tonic-gate if (cr1 == cr2)
6577c478bd9Sstevel@tonic-gate return (0);
6587c478bd9Sstevel@tonic-gate
6597c478bd9Sstevel@tonic-gate if (cr1->cr_uid == cr2->cr_uid &&
6607c478bd9Sstevel@tonic-gate cr1->cr_gid == cr2->cr_gid &&
6617c478bd9Sstevel@tonic-gate cr1->cr_ruid == cr2->cr_ruid &&
6627c478bd9Sstevel@tonic-gate cr1->cr_rgid == cr2->cr_rgid &&
6637c478bd9Sstevel@tonic-gate cr1->cr_zone == cr2->cr_zone &&
66467dbe2beSCasper H.S. Dik ((grp1 = cr1->cr_grps) == (grp2 = cr2->cr_grps) ||
66567dbe2beSCasper H.S. Dik (grp1 != NULL && grp2 != NULL &&
66667dbe2beSCasper H.S. Dik grp1->crg_ngroups == grp2->crg_ngroups &&
66767dbe2beSCasper H.S. Dik bcmp(grp1->crg_groups, grp2->crg_groups,
66867dbe2beSCasper H.S. Dik grp1->crg_ngroups * sizeof (gid_t)) == 0))) {
6697c478bd9Sstevel@tonic-gate return (!priv_isequalset(&CR_OEPRIV(cr1), &CR_OEPRIV(cr2)));
6707c478bd9Sstevel@tonic-gate }
6717c478bd9Sstevel@tonic-gate return (1);
6727c478bd9Sstevel@tonic-gate }
6737c478bd9Sstevel@tonic-gate
6747c478bd9Sstevel@tonic-gate /*
6757c478bd9Sstevel@tonic-gate * Read access functions to cred_t.
6767c478bd9Sstevel@tonic-gate */
6777c478bd9Sstevel@tonic-gate uid_t
crgetuid(const cred_t * cr)6787c478bd9Sstevel@tonic-gate crgetuid(const cred_t *cr)
6797c478bd9Sstevel@tonic-gate {
6807c478bd9Sstevel@tonic-gate return (cr->cr_uid);
6817c478bd9Sstevel@tonic-gate }
6827c478bd9Sstevel@tonic-gate
6837c478bd9Sstevel@tonic-gate uid_t
crgetruid(const cred_t * cr)6847c478bd9Sstevel@tonic-gate crgetruid(const cred_t *cr)
6857c478bd9Sstevel@tonic-gate {
6867c478bd9Sstevel@tonic-gate return (cr->cr_ruid);
6877c478bd9Sstevel@tonic-gate }
6887c478bd9Sstevel@tonic-gate
6897c478bd9Sstevel@tonic-gate uid_t
crgetsuid(const cred_t * cr)6907c478bd9Sstevel@tonic-gate crgetsuid(const cred_t *cr)
6917c478bd9Sstevel@tonic-gate {
6927c478bd9Sstevel@tonic-gate return (cr->cr_suid);
6937c478bd9Sstevel@tonic-gate }
6947c478bd9Sstevel@tonic-gate
6957c478bd9Sstevel@tonic-gate gid_t
crgetgid(const cred_t * cr)6967c478bd9Sstevel@tonic-gate crgetgid(const cred_t *cr)
6977c478bd9Sstevel@tonic-gate {
6987c478bd9Sstevel@tonic-gate return (cr->cr_gid);
6997c478bd9Sstevel@tonic-gate }
7007c478bd9Sstevel@tonic-gate
7017c478bd9Sstevel@tonic-gate gid_t
crgetrgid(const cred_t * cr)7027c478bd9Sstevel@tonic-gate crgetrgid(const cred_t *cr)
7037c478bd9Sstevel@tonic-gate {
7047c478bd9Sstevel@tonic-gate return (cr->cr_rgid);
7057c478bd9Sstevel@tonic-gate }
7067c478bd9Sstevel@tonic-gate
7077c478bd9Sstevel@tonic-gate gid_t
crgetsgid(const cred_t * cr)7087c478bd9Sstevel@tonic-gate crgetsgid(const cred_t *cr)
7097c478bd9Sstevel@tonic-gate {
7107c478bd9Sstevel@tonic-gate return (cr->cr_sgid);
7117c478bd9Sstevel@tonic-gate }
7127c478bd9Sstevel@tonic-gate
7137c478bd9Sstevel@tonic-gate const auditinfo_addr_t *
crgetauinfo(const cred_t * cr)7147c478bd9Sstevel@tonic-gate crgetauinfo(const cred_t *cr)
7157c478bd9Sstevel@tonic-gate {
7167c478bd9Sstevel@tonic-gate return ((const auditinfo_addr_t *)CR_AUINFO(cr));
7177c478bd9Sstevel@tonic-gate }
7187c478bd9Sstevel@tonic-gate
7197c478bd9Sstevel@tonic-gate auditinfo_addr_t *
crgetauinfo_modifiable(cred_t * cr)7207c478bd9Sstevel@tonic-gate crgetauinfo_modifiable(cred_t *cr)
7217c478bd9Sstevel@tonic-gate {
7227c478bd9Sstevel@tonic-gate return (CR_AUINFO(cr));
7237c478bd9Sstevel@tonic-gate }
7247c478bd9Sstevel@tonic-gate
7257c478bd9Sstevel@tonic-gate zoneid_t
crgetzoneid(const cred_t * cr)7267c478bd9Sstevel@tonic-gate crgetzoneid(const cred_t *cr)
7277c478bd9Sstevel@tonic-gate {
72845916cd2Sjpk return (cr->cr_zone == NULL ?
72945916cd2Sjpk (cr->cr_uid == -1 ? (zoneid_t)-1 : GLOBAL_ZONEID) :
73045916cd2Sjpk cr->cr_zone->zone_id);
7317c478bd9Sstevel@tonic-gate }
7327c478bd9Sstevel@tonic-gate
7337c478bd9Sstevel@tonic-gate projid_t
crgetprojid(const cred_t * cr)7347c478bd9Sstevel@tonic-gate crgetprojid(const cred_t *cr)
7357c478bd9Sstevel@tonic-gate {
7367c478bd9Sstevel@tonic-gate return (cr->cr_projid);
7377c478bd9Sstevel@tonic-gate }
7387c478bd9Sstevel@tonic-gate
73945916cd2Sjpk zone_t *
crgetzone(const cred_t * cr)74045916cd2Sjpk crgetzone(const cred_t *cr)
74145916cd2Sjpk {
74245916cd2Sjpk return (cr->cr_zone);
74345916cd2Sjpk }
74445916cd2Sjpk
74545916cd2Sjpk struct ts_label_s *
crgetlabel(const cred_t * cr)74645916cd2Sjpk crgetlabel(const cred_t *cr)
74745916cd2Sjpk {
74845916cd2Sjpk return (cr->cr_label ?
74945916cd2Sjpk cr->cr_label :
75045916cd2Sjpk (cr->cr_zone ? cr->cr_zone->zone_slabel : NULL));
75145916cd2Sjpk }
75245916cd2Sjpk
75345916cd2Sjpk boolean_t
crisremote(const cred_t * cr)75445916cd2Sjpk crisremote(const cred_t *cr)
75545916cd2Sjpk {
75645916cd2Sjpk return (REMOTE_PEER_CRED(cr));
75745916cd2Sjpk }
75845916cd2Sjpk
759bda89588Sjp #define BADUID(x, zn) ((x) != -1 && !VALID_UID((x), (zn)))
760bda89588Sjp #define BADGID(x, zn) ((x) != -1 && !VALID_GID((x), (zn)))
7617c478bd9Sstevel@tonic-gate
7627c478bd9Sstevel@tonic-gate int
crsetresuid(cred_t * cr,uid_t r,uid_t e,uid_t s)7637c478bd9Sstevel@tonic-gate crsetresuid(cred_t *cr, uid_t r, uid_t e, uid_t s)
7647c478bd9Sstevel@tonic-gate {
765bda89588Sjp zone_t *zone = crgetzone(cr);
766bda89588Sjp
7677c478bd9Sstevel@tonic-gate ASSERT(cr->cr_ref <= 2);
7687c478bd9Sstevel@tonic-gate
769bda89588Sjp if (BADUID(r, zone) || BADUID(e, zone) || BADUID(s, zone))
7707c478bd9Sstevel@tonic-gate return (-1);
7717c478bd9Sstevel@tonic-gate
7727c478bd9Sstevel@tonic-gate if (r != -1)
7737c478bd9Sstevel@tonic-gate cr->cr_ruid = r;
7747c478bd9Sstevel@tonic-gate if (e != -1)
7757c478bd9Sstevel@tonic-gate cr->cr_uid = e;
7767c478bd9Sstevel@tonic-gate if (s != -1)
7777c478bd9Sstevel@tonic-gate cr->cr_suid = s;
7787c478bd9Sstevel@tonic-gate
7797c478bd9Sstevel@tonic-gate return (0);
7807c478bd9Sstevel@tonic-gate }
7817c478bd9Sstevel@tonic-gate
7827c478bd9Sstevel@tonic-gate int
crsetresgid(cred_t * cr,gid_t r,gid_t e,gid_t s)7837c478bd9Sstevel@tonic-gate crsetresgid(cred_t *cr, gid_t r, gid_t e, gid_t s)
7847c478bd9Sstevel@tonic-gate {
785bda89588Sjp zone_t *zone = crgetzone(cr);
786bda89588Sjp
7877c478bd9Sstevel@tonic-gate ASSERT(cr->cr_ref <= 2);
7887c478bd9Sstevel@tonic-gate
789bda89588Sjp if (BADGID(r, zone) || BADGID(e, zone) || BADGID(s, zone))
7907c478bd9Sstevel@tonic-gate return (-1);
7917c478bd9Sstevel@tonic-gate
7927c478bd9Sstevel@tonic-gate if (r != -1)
7937c478bd9Sstevel@tonic-gate cr->cr_rgid = r;
7947c478bd9Sstevel@tonic-gate if (e != -1)
7957c478bd9Sstevel@tonic-gate cr->cr_gid = e;
7967c478bd9Sstevel@tonic-gate if (s != -1)
7977c478bd9Sstevel@tonic-gate cr->cr_sgid = s;
7987c478bd9Sstevel@tonic-gate
7997c478bd9Sstevel@tonic-gate return (0);
8007c478bd9Sstevel@tonic-gate }
8017c478bd9Sstevel@tonic-gate
8027c478bd9Sstevel@tonic-gate int
crsetugid(cred_t * cr,uid_t uid,gid_t gid)8037c478bd9Sstevel@tonic-gate crsetugid(cred_t *cr, uid_t uid, gid_t gid)
8047c478bd9Sstevel@tonic-gate {
805bda89588Sjp zone_t *zone = crgetzone(cr);
806bda89588Sjp
8077c478bd9Sstevel@tonic-gate ASSERT(cr->cr_ref <= 2);
8087c478bd9Sstevel@tonic-gate
809bda89588Sjp if (!VALID_UID(uid, zone) || !VALID_GID(gid, zone))
8107c478bd9Sstevel@tonic-gate return (-1);
8117c478bd9Sstevel@tonic-gate
8127c478bd9Sstevel@tonic-gate cr->cr_uid = cr->cr_ruid = cr->cr_suid = uid;
8137c478bd9Sstevel@tonic-gate cr->cr_gid = cr->cr_rgid = cr->cr_sgid = gid;
8147c478bd9Sstevel@tonic-gate
8157c478bd9Sstevel@tonic-gate return (0);
8167c478bd9Sstevel@tonic-gate }
8177c478bd9Sstevel@tonic-gate
81867dbe2beSCasper H.S. Dik static int
gidcmp(const void * v1,const void * v2)81967dbe2beSCasper H.S. Dik gidcmp(const void *v1, const void *v2)
82067dbe2beSCasper H.S. Dik {
82167dbe2beSCasper H.S. Dik gid_t g1 = *(gid_t *)v1;
82267dbe2beSCasper H.S. Dik gid_t g2 = *(gid_t *)v2;
82367dbe2beSCasper H.S. Dik
82467dbe2beSCasper H.S. Dik if (g1 < g2)
82567dbe2beSCasper H.S. Dik return (-1);
82667dbe2beSCasper H.S. Dik else if (g1 > g2)
82767dbe2beSCasper H.S. Dik return (1);
82867dbe2beSCasper H.S. Dik else
82967dbe2beSCasper H.S. Dik return (0);
83067dbe2beSCasper H.S. Dik }
83167dbe2beSCasper H.S. Dik
8327c478bd9Sstevel@tonic-gate int
crsetgroups(cred_t * cr,int n,gid_t * grp)8337c478bd9Sstevel@tonic-gate crsetgroups(cred_t *cr, int n, gid_t *grp)
8347c478bd9Sstevel@tonic-gate {
8357c478bd9Sstevel@tonic-gate ASSERT(cr->cr_ref <= 2);
8367c478bd9Sstevel@tonic-gate
8377c478bd9Sstevel@tonic-gate if (n > ngroups_max || n < 0)
8387c478bd9Sstevel@tonic-gate return (-1);
8397c478bd9Sstevel@tonic-gate
84067dbe2beSCasper H.S. Dik if (cr->cr_grps != NULL)
84167dbe2beSCasper H.S. Dik crgrprele(cr->cr_grps);
8427c478bd9Sstevel@tonic-gate
84367dbe2beSCasper H.S. Dik if (n > 0) {
84467dbe2beSCasper H.S. Dik cr->cr_grps = kmem_alloc(CREDGRPSZ(n), KM_SLEEP);
84567dbe2beSCasper H.S. Dik bcopy(grp, cr->cr_grps->crg_groups, n * sizeof (gid_t));
84667dbe2beSCasper H.S. Dik cr->cr_grps->crg_ref = 1;
84767dbe2beSCasper H.S. Dik cr->cr_grps->crg_ngroups = n;
84867dbe2beSCasper H.S. Dik qsort(cr->cr_grps->crg_groups, n, sizeof (gid_t), gidcmp);
84967dbe2beSCasper H.S. Dik } else {
85067dbe2beSCasper H.S. Dik cr->cr_grps = NULL;
85167dbe2beSCasper H.S. Dik }
8527c478bd9Sstevel@tonic-gate
8537c478bd9Sstevel@tonic-gate return (0);
8547c478bd9Sstevel@tonic-gate }
8557c478bd9Sstevel@tonic-gate
8567c478bd9Sstevel@tonic-gate void
crsetprojid(cred_t * cr,projid_t projid)8577c478bd9Sstevel@tonic-gate crsetprojid(cred_t *cr, projid_t projid)
8587c478bd9Sstevel@tonic-gate {
8597c478bd9Sstevel@tonic-gate ASSERT(projid >= 0 && projid <= MAXPROJID);
8607c478bd9Sstevel@tonic-gate cr->cr_projid = projid;
8617c478bd9Sstevel@tonic-gate }
8627c478bd9Sstevel@tonic-gate
8637c478bd9Sstevel@tonic-gate /*
86467dbe2beSCasper H.S. Dik * This routine returns the pointer to the first element of the crg_groups
8657c478bd9Sstevel@tonic-gate * array. It can move around in an implementation defined way.
86667dbe2beSCasper H.S. Dik * Note that when we have no grouplist, we return one element but the
86767dbe2beSCasper H.S. Dik * caller should never reference it.
8687c478bd9Sstevel@tonic-gate */
8697c478bd9Sstevel@tonic-gate const gid_t *
crgetgroups(const cred_t * cr)8707c478bd9Sstevel@tonic-gate crgetgroups(const cred_t *cr)
8717c478bd9Sstevel@tonic-gate {
87267dbe2beSCasper H.S. Dik return (cr->cr_grps == NULL ? &cr->cr_gid : cr->cr_grps->crg_groups);
8737c478bd9Sstevel@tonic-gate }
8747c478bd9Sstevel@tonic-gate
8757c478bd9Sstevel@tonic-gate int
crgetngroups(const cred_t * cr)8767c478bd9Sstevel@tonic-gate crgetngroups(const cred_t *cr)
8777c478bd9Sstevel@tonic-gate {
87867dbe2beSCasper H.S. Dik return (cr->cr_grps == NULL ? 0 : cr->cr_grps->crg_ngroups);
8797c478bd9Sstevel@tonic-gate }
8807c478bd9Sstevel@tonic-gate
8817c478bd9Sstevel@tonic-gate void
cred2prcred(const cred_t * cr,prcred_t * pcrp)8827c478bd9Sstevel@tonic-gate cred2prcred(const cred_t *cr, prcred_t *pcrp)
8837c478bd9Sstevel@tonic-gate {
8847c478bd9Sstevel@tonic-gate pcrp->pr_euid = cr->cr_uid;
8857c478bd9Sstevel@tonic-gate pcrp->pr_ruid = cr->cr_ruid;
8867c478bd9Sstevel@tonic-gate pcrp->pr_suid = cr->cr_suid;
8877c478bd9Sstevel@tonic-gate pcrp->pr_egid = cr->cr_gid;
8887c478bd9Sstevel@tonic-gate pcrp->pr_rgid = cr->cr_rgid;
8897c478bd9Sstevel@tonic-gate pcrp->pr_sgid = cr->cr_sgid;
89067dbe2beSCasper H.S. Dik pcrp->pr_groups[0] = 0; /* in case ngroups == 0 */
89167dbe2beSCasper H.S. Dik pcrp->pr_ngroups = cr->cr_grps == NULL ? 0 : cr->cr_grps->crg_ngroups;
8927c478bd9Sstevel@tonic-gate
8937c478bd9Sstevel@tonic-gate if (pcrp->pr_ngroups != 0)
89467dbe2beSCasper H.S. Dik bcopy(cr->cr_grps->crg_groups, pcrp->pr_groups,
89567dbe2beSCasper H.S. Dik sizeof (gid_t) * pcrp->pr_ngroups);
8967c478bd9Sstevel@tonic-gate }
8977c478bd9Sstevel@tonic-gate
8987c478bd9Sstevel@tonic-gate static int
cred2ucaud(const cred_t * cr,auditinfo64_addr_t * ainfo,const cred_t * rcr)89945916cd2Sjpk cred2ucaud(const cred_t *cr, auditinfo64_addr_t *ainfo, const cred_t *rcr)
9007c478bd9Sstevel@tonic-gate {
9017c478bd9Sstevel@tonic-gate auditinfo_addr_t *ai;
9027c478bd9Sstevel@tonic-gate au_tid_addr_t tid;
9037c478bd9Sstevel@tonic-gate
904134a1f4eSCasper H.S. Dik if (secpolicy_audit_getattr(rcr, B_TRUE) != 0)
9057c478bd9Sstevel@tonic-gate return (-1);
9067c478bd9Sstevel@tonic-gate
9077c478bd9Sstevel@tonic-gate ai = CR_AUINFO(cr); /* caller makes sure this is non-NULL */
9087c478bd9Sstevel@tonic-gate tid = ai->ai_termid;
9097c478bd9Sstevel@tonic-gate
9107c478bd9Sstevel@tonic-gate ainfo->ai_auid = ai->ai_auid;
9117c478bd9Sstevel@tonic-gate ainfo->ai_mask = ai->ai_mask;
9127c478bd9Sstevel@tonic-gate ainfo->ai_asid = ai->ai_asid;
9137c478bd9Sstevel@tonic-gate
9147c478bd9Sstevel@tonic-gate ainfo->ai_termid.at_type = tid.at_type;
9157c478bd9Sstevel@tonic-gate bcopy(&tid.at_addr, &ainfo->ai_termid.at_addr, 4 * sizeof (uint_t));
9167c478bd9Sstevel@tonic-gate
9177c478bd9Sstevel@tonic-gate ainfo->ai_termid.at_port.at_major = (uint32_t)getmajor(tid.at_port);
9187c478bd9Sstevel@tonic-gate ainfo->ai_termid.at_port.at_minor = (uint32_t)getminor(tid.at_port);
9197c478bd9Sstevel@tonic-gate
9207c478bd9Sstevel@tonic-gate return (0);
9217c478bd9Sstevel@tonic-gate }
9227c478bd9Sstevel@tonic-gate
92345916cd2Sjpk void
cred2uclabel(const cred_t * cr,bslabel_t * labelp)92445916cd2Sjpk cred2uclabel(const cred_t *cr, bslabel_t *labelp)
92545916cd2Sjpk {
92645916cd2Sjpk ts_label_t *tslp;
92745916cd2Sjpk
92845916cd2Sjpk if ((tslp = crgetlabel(cr)) != NULL)
92945916cd2Sjpk bcopy(&tslp->tsl_label, labelp, sizeof (bslabel_t));
93045916cd2Sjpk }
93145916cd2Sjpk
9327c478bd9Sstevel@tonic-gate /*
9337c478bd9Sstevel@tonic-gate * Convert a credential into a "ucred". Allow the caller to specify
9347c478bd9Sstevel@tonic-gate * and aligned buffer, e.g., in an mblk, so we don't have to allocate
9357c478bd9Sstevel@tonic-gate * memory and copy it twice.
93645916cd2Sjpk *
93745916cd2Sjpk * This function may call cred2ucaud(), which calls CRED(). Since this
93845916cd2Sjpk * can be called from an interrupt thread, receiver's cred (rcr) is needed
93945916cd2Sjpk * to determine whether audit info should be included.
9407c478bd9Sstevel@tonic-gate */
9417c478bd9Sstevel@tonic-gate struct ucred_s *
cred2ucred(const cred_t * cr,pid_t pid,void * buf,const cred_t * rcr)94245916cd2Sjpk cred2ucred(const cred_t *cr, pid_t pid, void *buf, const cred_t *rcr)
9437c478bd9Sstevel@tonic-gate {
9447c478bd9Sstevel@tonic-gate struct ucred_s *uc;
94567dbe2beSCasper H.S. Dik uint32_t realsz = ucredminsize(cr);
94667dbe2beSCasper H.S. Dik ts_label_t *tslp = is_system_labeled() ? crgetlabel(cr) : NULL;
9477c478bd9Sstevel@tonic-gate
9487c478bd9Sstevel@tonic-gate /* The structure isn't always completely filled in, so zero it */
9497c478bd9Sstevel@tonic-gate if (buf == NULL) {
95067dbe2beSCasper H.S. Dik uc = kmem_zalloc(realsz, KM_SLEEP);
9517c478bd9Sstevel@tonic-gate } else {
95267dbe2beSCasper H.S. Dik bzero(buf, realsz);
9537c478bd9Sstevel@tonic-gate uc = buf;
9547c478bd9Sstevel@tonic-gate }
95567dbe2beSCasper H.S. Dik uc->uc_size = realsz;
9567c478bd9Sstevel@tonic-gate uc->uc_pid = pid;
9577c478bd9Sstevel@tonic-gate uc->uc_projid = cr->cr_projid;
9587c478bd9Sstevel@tonic-gate uc->uc_zoneid = crgetzoneid(cr);
9597c478bd9Sstevel@tonic-gate
96045916cd2Sjpk if (REMOTE_PEER_CRED(cr)) {
96145916cd2Sjpk /*
96267dbe2beSCasper H.S. Dik * Other than label, the rest of cred info about a
96367dbe2beSCasper H.S. Dik * remote peer isn't available. Copy the label directly
96467dbe2beSCasper H.S. Dik * after the header where we generally copy the prcred.
96567dbe2beSCasper H.S. Dik * That's why we use sizeof (struct ucred_s). The other
96667dbe2beSCasper H.S. Dik * offset fields are initialized to 0.
96745916cd2Sjpk */
96867dbe2beSCasper H.S. Dik uc->uc_labeloff = tslp == NULL ? 0 : sizeof (struct ucred_s);
96945916cd2Sjpk } else {
97067dbe2beSCasper H.S. Dik uc->uc_credoff = UCRED_CRED_OFF;
97167dbe2beSCasper H.S. Dik uc->uc_privoff = UCRED_PRIV_OFF;
97267dbe2beSCasper H.S. Dik uc->uc_audoff = UCRED_AUD_OFF;
97367dbe2beSCasper H.S. Dik uc->uc_labeloff = tslp == NULL ? 0 : UCRED_LABEL_OFF;
97467dbe2beSCasper H.S. Dik
97545916cd2Sjpk cred2prcred(cr, UCCRED(uc));
97645916cd2Sjpk cred2prpriv(cr, UCPRIV(uc));
97767dbe2beSCasper H.S. Dik
97845916cd2Sjpk if (audoff == 0 || cred2ucaud(cr, UCAUD(uc), rcr) != 0)
97945916cd2Sjpk uc->uc_audoff = 0;
98045916cd2Sjpk }
98167dbe2beSCasper H.S. Dik if (tslp != NULL)
98267dbe2beSCasper H.S. Dik bcopy(&tslp->tsl_label, UCLABEL(uc), sizeof (bslabel_t));
9837c478bd9Sstevel@tonic-gate
9847c478bd9Sstevel@tonic-gate return (uc);
9857c478bd9Sstevel@tonic-gate }
9867c478bd9Sstevel@tonic-gate
98767dbe2beSCasper H.S. Dik /*
98867dbe2beSCasper H.S. Dik * Don't allocate the non-needed group entries. Note: this function
98967dbe2beSCasper H.S. Dik * must match the code in cred2ucred; they must agree about the
99067dbe2beSCasper H.S. Dik * minimal size of the ucred.
99167dbe2beSCasper H.S. Dik */
99267dbe2beSCasper H.S. Dik uint32_t
ucredminsize(const cred_t * cr)99367dbe2beSCasper H.S. Dik ucredminsize(const cred_t *cr)
99467dbe2beSCasper H.S. Dik {
99567dbe2beSCasper H.S. Dik int ndiff;
99667dbe2beSCasper H.S. Dik
99767dbe2beSCasper H.S. Dik if (cr == NULL)
99867dbe2beSCasper H.S. Dik return (ucredsize);
99967dbe2beSCasper H.S. Dik
100067dbe2beSCasper H.S. Dik if (REMOTE_PEER_CRED(cr)) {
100167dbe2beSCasper H.S. Dik if (is_system_labeled())
100267dbe2beSCasper H.S. Dik return (sizeof (struct ucred_s) + sizeof (bslabel_t));
100367dbe2beSCasper H.S. Dik else
100467dbe2beSCasper H.S. Dik return (sizeof (struct ucred_s));
100567dbe2beSCasper H.S. Dik }
100667dbe2beSCasper H.S. Dik
100767dbe2beSCasper H.S. Dik if (cr->cr_grps == NULL)
100867dbe2beSCasper H.S. Dik ndiff = ngroups_max - 1; /* Needs one for prcred_t */
100967dbe2beSCasper H.S. Dik else
101067dbe2beSCasper H.S. Dik ndiff = ngroups_max - cr->cr_grps->crg_ngroups;
101167dbe2beSCasper H.S. Dik
101267dbe2beSCasper H.S. Dik return (ucredsize - ndiff * sizeof (gid_t));
101367dbe2beSCasper H.S. Dik }
101467dbe2beSCasper H.S. Dik
10157c478bd9Sstevel@tonic-gate /*
10167c478bd9Sstevel@tonic-gate * Get the "ucred" of a process.
10177c478bd9Sstevel@tonic-gate */
10187c478bd9Sstevel@tonic-gate struct ucred_s *
pgetucred(proc_t * p)10197c478bd9Sstevel@tonic-gate pgetucred(proc_t *p)
10207c478bd9Sstevel@tonic-gate {
10217c478bd9Sstevel@tonic-gate cred_t *cr;
10227c478bd9Sstevel@tonic-gate struct ucred_s *uc;
10237c478bd9Sstevel@tonic-gate
10247c478bd9Sstevel@tonic-gate mutex_enter(&p->p_crlock);
10257c478bd9Sstevel@tonic-gate cr = p->p_cred;
10267c478bd9Sstevel@tonic-gate crhold(cr);
10277c478bd9Sstevel@tonic-gate mutex_exit(&p->p_crlock);
10287c478bd9Sstevel@tonic-gate
102945916cd2Sjpk uc = cred2ucred(cr, p->p_pid, NULL, CRED());
10307c478bd9Sstevel@tonic-gate crfree(cr);
10317c478bd9Sstevel@tonic-gate
10327c478bd9Sstevel@tonic-gate return (uc);
10337c478bd9Sstevel@tonic-gate }
10347c478bd9Sstevel@tonic-gate
10357c478bd9Sstevel@tonic-gate /*
10367c478bd9Sstevel@tonic-gate * If the reply status is NFSERR_EACCES, it may be because we are
10377c478bd9Sstevel@tonic-gate * root (no root net access). Check the real uid, if it isn't root
10387c478bd9Sstevel@tonic-gate * make that the uid instead and retry the call.
10397c478bd9Sstevel@tonic-gate * Private interface for NFS.
10407c478bd9Sstevel@tonic-gate */
10417c478bd9Sstevel@tonic-gate cred_t *
crnetadjust(cred_t * cr)10427c478bd9Sstevel@tonic-gate crnetadjust(cred_t *cr)
10437c478bd9Sstevel@tonic-gate {
10447c478bd9Sstevel@tonic-gate if (cr->cr_uid == 0 && cr->cr_ruid != 0) {
10457c478bd9Sstevel@tonic-gate cr = crdup(cr);
10467c478bd9Sstevel@tonic-gate cr->cr_uid = cr->cr_ruid;
10477c478bd9Sstevel@tonic-gate return (cr);
10487c478bd9Sstevel@tonic-gate }
10497c478bd9Sstevel@tonic-gate return (NULL);
10507c478bd9Sstevel@tonic-gate }
10517c478bd9Sstevel@tonic-gate
10527c478bd9Sstevel@tonic-gate /*
10537c478bd9Sstevel@tonic-gate * The reference count is of interest when you want to check
10547c478bd9Sstevel@tonic-gate * whether it is ok to modify the credential in place.
10557c478bd9Sstevel@tonic-gate */
10567c478bd9Sstevel@tonic-gate uint_t
crgetref(const cred_t * cr)10577c478bd9Sstevel@tonic-gate crgetref(const cred_t *cr)
10587c478bd9Sstevel@tonic-gate {
10597c478bd9Sstevel@tonic-gate return (cr->cr_ref);
10607c478bd9Sstevel@tonic-gate }
10617c478bd9Sstevel@tonic-gate
10627c478bd9Sstevel@tonic-gate static int
get_c2audit_load(void)10637c478bd9Sstevel@tonic-gate get_c2audit_load(void)
10647c478bd9Sstevel@tonic-gate {
10657c478bd9Sstevel@tonic-gate static int gotit = 0;
10667c478bd9Sstevel@tonic-gate static int c2audit_load;
10677c478bd9Sstevel@tonic-gate
10687c478bd9Sstevel@tonic-gate if (gotit)
10697c478bd9Sstevel@tonic-gate return (c2audit_load);
1070005d3febSMarek Pospisil c2audit_load = 1; /* set default value once */
1071005d3febSMarek Pospisil if (mod_sysctl(SYS_CHECK_EXCLUDE, "c2audit") != 0)
1072005d3febSMarek Pospisil c2audit_load = 0;
10737c478bd9Sstevel@tonic-gate gotit++;
1074005d3febSMarek Pospisil
10757c478bd9Sstevel@tonic-gate return (c2audit_load);
10767c478bd9Sstevel@tonic-gate }
10777c478bd9Sstevel@tonic-gate
10787c478bd9Sstevel@tonic-gate int
get_audit_ucrsize(void)10797c478bd9Sstevel@tonic-gate get_audit_ucrsize(void)
10807c478bd9Sstevel@tonic-gate {
10817c478bd9Sstevel@tonic-gate return (get_c2audit_load() ? sizeof (auditinfo64_addr_t) : 0);
10827c478bd9Sstevel@tonic-gate }
10837c478bd9Sstevel@tonic-gate
10847c478bd9Sstevel@tonic-gate /*
10857c478bd9Sstevel@tonic-gate * Set zone pointer in credential to indicated value. First adds a
10867c478bd9Sstevel@tonic-gate * hold for the new zone, then drops the hold on previous zone (if any).
10877c478bd9Sstevel@tonic-gate * This is done in this order in case the old and new zones are the
10887c478bd9Sstevel@tonic-gate * same.
10897c478bd9Sstevel@tonic-gate */
10907c478bd9Sstevel@tonic-gate void
crsetzone(cred_t * cr,zone_t * zptr)10917c478bd9Sstevel@tonic-gate crsetzone(cred_t *cr, zone_t *zptr)
10927c478bd9Sstevel@tonic-gate {
10937c478bd9Sstevel@tonic-gate zone_t *oldzptr = cr->cr_zone;
10947c478bd9Sstevel@tonic-gate
10957c478bd9Sstevel@tonic-gate ASSERT(cr != kcred);
10967c478bd9Sstevel@tonic-gate ASSERT(cr->cr_ref <= 2);
10977c478bd9Sstevel@tonic-gate cr->cr_zone = zptr;
10987c478bd9Sstevel@tonic-gate zone_cred_hold(zptr);
10997c478bd9Sstevel@tonic-gate if (oldzptr)
11007c478bd9Sstevel@tonic-gate zone_cred_rele(oldzptr);
11017c478bd9Sstevel@tonic-gate }
110245916cd2Sjpk
110345916cd2Sjpk /*
110445916cd2Sjpk * Create a new cred based on the supplied label
110545916cd2Sjpk */
110645916cd2Sjpk cred_t *
newcred_from_bslabel(bslabel_t * blabel,uint32_t doi,int flags)110745916cd2Sjpk newcred_from_bslabel(bslabel_t *blabel, uint32_t doi, int flags)
110845916cd2Sjpk {
110945916cd2Sjpk ts_label_t *lbl = labelalloc(blabel, doi, flags);
111045916cd2Sjpk cred_t *cr = NULL;
111145916cd2Sjpk
111245916cd2Sjpk if (lbl != NULL) {
1113ddf7fe95Scasper if ((cr = crdup_flags(dummycr, flags)) != NULL) {
111445916cd2Sjpk cr->cr_label = lbl;
111545916cd2Sjpk } else {
111645916cd2Sjpk label_rele(lbl);
111745916cd2Sjpk }
111845916cd2Sjpk }
111945916cd2Sjpk
112045916cd2Sjpk return (cr);
112145916cd2Sjpk }
112245916cd2Sjpk
112345916cd2Sjpk /*
112445916cd2Sjpk * Derive a new cred from the existing cred, but with a different label.
112545916cd2Sjpk * To be used when a cred is being shared, but the label needs to be changed
112645916cd2Sjpk * by a caller without affecting other users
112745916cd2Sjpk */
112845916cd2Sjpk cred_t *
copycred_from_tslabel(const cred_t * cr,ts_label_t * label,int flags)11295f9878b0Sken Powell - Sun Microsystem copycred_from_tslabel(const cred_t *cr, ts_label_t *label, int flags)
113045916cd2Sjpk {
113145916cd2Sjpk cred_t *newcr = NULL;
113245916cd2Sjpk
11335f9878b0Sken Powell - Sun Microsystem if ((newcr = crdup_flags(cr, flags)) != NULL) {
11345f9878b0Sken Powell - Sun Microsystem if (newcr->cr_label != NULL)
11355f9878b0Sken Powell - Sun Microsystem label_rele(newcr->cr_label);
11365f9878b0Sken Powell - Sun Microsystem label_hold(label);
11375f9878b0Sken Powell - Sun Microsystem newcr->cr_label = label;
11385f9878b0Sken Powell - Sun Microsystem }
11395f9878b0Sken Powell - Sun Microsystem
11405f9878b0Sken Powell - Sun Microsystem return (newcr);
11415f9878b0Sken Powell - Sun Microsystem }
11425f9878b0Sken Powell - Sun Microsystem
11435f9878b0Sken Powell - Sun Microsystem /*
11445f9878b0Sken Powell - Sun Microsystem * Derive a new cred from the existing cred, but with a different label.
11455f9878b0Sken Powell - Sun Microsystem */
11465f9878b0Sken Powell - Sun Microsystem cred_t *
copycred_from_bslabel(const cred_t * cr,bslabel_t * blabel,uint32_t doi,int flags)11475f9878b0Sken Powell - Sun Microsystem copycred_from_bslabel(const cred_t *cr, bslabel_t *blabel,
11485f9878b0Sken Powell - Sun Microsystem uint32_t doi, int flags)
11495f9878b0Sken Powell - Sun Microsystem {
11505f9878b0Sken Powell - Sun Microsystem ts_label_t *lbl = labelalloc(blabel, doi, flags);
11515f9878b0Sken Powell - Sun Microsystem cred_t *newcr = NULL;
11525f9878b0Sken Powell - Sun Microsystem
115345916cd2Sjpk if (lbl != NULL) {
11545f9878b0Sken Powell - Sun Microsystem newcr = copycred_from_tslabel(cr, lbl, flags);
11555f9878b0Sken Powell - Sun Microsystem label_rele(lbl);
115645916cd2Sjpk }
115745916cd2Sjpk
115845916cd2Sjpk return (newcr);
115945916cd2Sjpk }
116045916cd2Sjpk
116145916cd2Sjpk /*
116245916cd2Sjpk * This function returns a pointer to the kcred-equivalent in the current zone.
116345916cd2Sjpk */
116445916cd2Sjpk cred_t *
zone_kcred(void)116545916cd2Sjpk zone_kcred(void)
116645916cd2Sjpk {
116745916cd2Sjpk zone_t *zone;
116845916cd2Sjpk
116945916cd2Sjpk if ((zone = CRED()->cr_zone) != NULL)
117045916cd2Sjpk return (zone->zone_kcred);
117145916cd2Sjpk else
117245916cd2Sjpk return (kcred);
117345916cd2Sjpk }
1174f48205beScasper
1175f48205beScasper boolean_t
valid_ephemeral_uid(zone_t * zone,uid_t id)1176bda89588Sjp valid_ephemeral_uid(zone_t *zone, uid_t id)
1177f48205beScasper {
1178bda89588Sjp ephemeral_zsd_t *eph_zsd;
11794edd44c5Sjp if (id <= IDMAP_WK__MAX_UID)
1180bda89588Sjp return (B_TRUE);
1181bda89588Sjp
1182bda89588Sjp eph_zsd = get_ephemeral_zsd(zone);
1183bda89588Sjp ASSERT(eph_zsd != NULL);
1184f48205beScasper membar_consumer();
1185bda89588Sjp return (id > eph_zsd->min_uid && id <= eph_zsd->last_uid);
1186f48205beScasper }
1187f48205beScasper
1188f48205beScasper boolean_t
valid_ephemeral_gid(zone_t * zone,gid_t id)1189bda89588Sjp valid_ephemeral_gid(zone_t *zone, gid_t id)
1190f48205beScasper {
1191bda89588Sjp ephemeral_zsd_t *eph_zsd;
11924edd44c5Sjp if (id <= IDMAP_WK__MAX_GID)
1193bda89588Sjp return (B_TRUE);
1194bda89588Sjp
1195bda89588Sjp eph_zsd = get_ephemeral_zsd(zone);
1196bda89588Sjp ASSERT(eph_zsd != NULL);
1197f48205beScasper membar_consumer();
1198bda89588Sjp return (id > eph_zsd->min_gid && id <= eph_zsd->last_gid);
1199f48205beScasper }
1200f48205beScasper
1201f48205beScasper int
eph_uid_alloc(zone_t * zone,int flags,uid_t * start,int count)1202bda89588Sjp eph_uid_alloc(zone_t *zone, int flags, uid_t *start, int count)
1203f48205beScasper {
1204bda89588Sjp ephemeral_zsd_t *eph_zsd = get_ephemeral_zsd(zone);
1205bda89588Sjp
1206bda89588Sjp ASSERT(eph_zsd != NULL);
1207bda89588Sjp
1208bda89588Sjp mutex_enter(&eph_zsd->eph_lock);
1209f48205beScasper
1210f48205beScasper /* Test for unsigned integer wrap around */
1211bda89588Sjp if (eph_zsd->last_uid + count < eph_zsd->last_uid) {
1212bda89588Sjp mutex_exit(&eph_zsd->eph_lock);
1213f48205beScasper return (-1);
1214f48205beScasper }
1215f48205beScasper
1216f48205beScasper /* first call or idmap crashed and state corrupted */
1217f48205beScasper if (flags != 0)
1218bda89588Sjp eph_zsd->min_uid = eph_zsd->last_uid;
1219f48205beScasper
1220f48205beScasper hasephids = B_TRUE;
1221bda89588Sjp *start = eph_zsd->last_uid + 1;
1222bda89588Sjp atomic_add_32(&eph_zsd->last_uid, count);
1223bda89588Sjp mutex_exit(&eph_zsd->eph_lock);
1224f48205beScasper return (0);
1225f48205beScasper }
1226f48205beScasper
1227f48205beScasper int
eph_gid_alloc(zone_t * zone,int flags,gid_t * start,int count)1228bda89588Sjp eph_gid_alloc(zone_t *zone, int flags, gid_t *start, int count)
1229f48205beScasper {
1230bda89588Sjp ephemeral_zsd_t *eph_zsd = get_ephemeral_zsd(zone);
1231bda89588Sjp
1232bda89588Sjp ASSERT(eph_zsd != NULL);
1233bda89588Sjp
1234bda89588Sjp mutex_enter(&eph_zsd->eph_lock);
1235f48205beScasper
1236f48205beScasper /* Test for unsigned integer wrap around */
1237bda89588Sjp if (eph_zsd->last_gid + count < eph_zsd->last_gid) {
1238bda89588Sjp mutex_exit(&eph_zsd->eph_lock);
1239f48205beScasper return (-1);
1240f48205beScasper }
1241f48205beScasper
1242f48205beScasper /* first call or idmap crashed and state corrupted */
1243f48205beScasper if (flags != 0)
1244bda89588Sjp eph_zsd->min_gid = eph_zsd->last_gid;
1245f48205beScasper
1246f48205beScasper hasephids = B_TRUE;
1247bda89588Sjp *start = eph_zsd->last_gid + 1;
1248bda89588Sjp atomic_add_32(&eph_zsd->last_gid, count);
1249bda89588Sjp mutex_exit(&eph_zsd->eph_lock);
1250f48205beScasper return (0);
1251f48205beScasper }
1252f48205beScasper
1253bda89588Sjp /*
1254bda89588Sjp * IMPORTANT.The two functions get_ephemeral_data() and set_ephemeral_data()
1255bda89588Sjp * are project private functions that are for use of the test system only and
1256bda89588Sjp * are not to be used for other purposes.
1257bda89588Sjp */
1258bda89588Sjp
1259bda89588Sjp void
get_ephemeral_data(zone_t * zone,uid_t * min_uid,uid_t * last_uid,gid_t * min_gid,gid_t * last_gid)1260bda89588Sjp get_ephemeral_data(zone_t *zone, uid_t *min_uid, uid_t *last_uid,
1261d2a70789SRichard Lowe gid_t *min_gid, gid_t *last_gid)
1262bda89588Sjp {
1263bda89588Sjp ephemeral_zsd_t *eph_zsd = get_ephemeral_zsd(zone);
1264bda89588Sjp
1265bda89588Sjp ASSERT(eph_zsd != NULL);
1266bda89588Sjp
1267bda89588Sjp mutex_enter(&eph_zsd->eph_lock);
1268bda89588Sjp
1269bda89588Sjp *min_uid = eph_zsd->min_uid;
1270bda89588Sjp *last_uid = eph_zsd->last_uid;
1271bda89588Sjp *min_gid = eph_zsd->min_gid;
1272bda89588Sjp *last_gid = eph_zsd->last_gid;
1273bda89588Sjp
1274bda89588Sjp mutex_exit(&eph_zsd->eph_lock);
1275bda89588Sjp }
1276bda89588Sjp
1277bda89588Sjp
1278bda89588Sjp void
set_ephemeral_data(zone_t * zone,uid_t min_uid,uid_t last_uid,gid_t min_gid,gid_t last_gid)1279bda89588Sjp set_ephemeral_data(zone_t *zone, uid_t min_uid, uid_t last_uid,
1280d2a70789SRichard Lowe gid_t min_gid, gid_t last_gid)
1281bda89588Sjp {
1282bda89588Sjp ephemeral_zsd_t *eph_zsd = get_ephemeral_zsd(zone);
1283bda89588Sjp
1284bda89588Sjp ASSERT(eph_zsd != NULL);
1285bda89588Sjp
1286bda89588Sjp mutex_enter(&eph_zsd->eph_lock);
1287bda89588Sjp
1288bda89588Sjp if (min_uid != 0)
1289bda89588Sjp eph_zsd->min_uid = min_uid;
1290bda89588Sjp if (last_uid != 0)
1291bda89588Sjp eph_zsd->last_uid = last_uid;
1292bda89588Sjp if (min_gid != 0)
1293bda89588Sjp eph_zsd->min_gid = min_gid;
1294bda89588Sjp if (last_gid != 0)
1295bda89588Sjp eph_zsd->last_gid = last_gid;
1296bda89588Sjp
1297bda89588Sjp mutex_exit(&eph_zsd->eph_lock);
1298bda89588Sjp }
1299bda89588Sjp
1300f48205beScasper /*
1301da6c28aaSamw * If the credential user SID or group SID is mapped to an ephemeral
1302da6c28aaSamw * ID, map the credential to nobody.
1303f48205beScasper */
1304f48205beScasper cred_t *
crgetmapped(const cred_t * cr)1305f48205beScasper crgetmapped(const cred_t *cr)
1306f48205beScasper {
1307bda89588Sjp ephemeral_zsd_t *eph_zsd;
130890c3d472Scasper /*
130990c3d472Scasper * Someone incorrectly passed a NULL cred to a vnode operation
131090c3d472Scasper * either on purpose or by calling CRED() in interrupt context.
131190c3d472Scasper */
131290c3d472Scasper if (cr == NULL)
131390c3d472Scasper return (NULL);
131490c3d472Scasper
1315f48205beScasper if (cr->cr_ksid != NULL) {
1316bda89588Sjp if (cr->cr_ksid->kr_sidx[KSID_USER].ks_id > MAXUID) {
1317bda89588Sjp eph_zsd = get_ephemeral_zsd(crgetzone(cr));
1318bda89588Sjp return (eph_zsd->eph_nobody);
1319bda89588Sjp }
1320da6c28aaSamw
1321bda89588Sjp if (cr->cr_ksid->kr_sidx[KSID_GROUP].ks_id > MAXUID) {
1322bda89588Sjp eph_zsd = get_ephemeral_zsd(crgetzone(cr));
1323bda89588Sjp return (eph_zsd->eph_nobody);
1324bda89588Sjp }
1325f48205beScasper }
1326f48205beScasper
1327f48205beScasper return ((cred_t *)cr);
1328f48205beScasper }
1329f48205beScasper
1330f48205beScasper /* index should be in range for a ksidindex_t */
1331f48205beScasper void
crsetsid(cred_t * cr,ksid_t * ksp,int index)1332f48205beScasper crsetsid(cred_t *cr, ksid_t *ksp, int index)
1333f48205beScasper {
1334f48205beScasper ASSERT(cr->cr_ref <= 2);
1335f48205beScasper ASSERT(index >= 0 && index < KSID_COUNT);
1336f48205beScasper if (cr->cr_ksid == NULL && ksp == NULL)
1337f48205beScasper return;
1338f48205beScasper cr->cr_ksid = kcrsid_setsid(cr->cr_ksid, ksp, index);
1339f48205beScasper }
1340f48205beScasper
1341f48205beScasper void
crsetsidlist(cred_t * cr,ksidlist_t * ksl)1342f48205beScasper crsetsidlist(cred_t *cr, ksidlist_t *ksl)
1343f48205beScasper {
1344f48205beScasper ASSERT(cr->cr_ref <= 2);
1345f48205beScasper if (cr->cr_ksid == NULL && ksl == NULL)
1346f48205beScasper return;
1347f48205beScasper cr->cr_ksid = kcrsid_setsidlist(cr->cr_ksid, ksl);
1348f48205beScasper }
1349f48205beScasper
1350f48205beScasper ksid_t *
crgetsid(const cred_t * cr,int i)1351f48205beScasper crgetsid(const cred_t *cr, int i)
1352f48205beScasper {
1353f48205beScasper ASSERT(i >= 0 && i < KSID_COUNT);
1354f48205beScasper if (cr->cr_ksid != NULL && cr->cr_ksid->kr_sidx[i].ks_domain)
1355f48205beScasper return ((ksid_t *)&cr->cr_ksid->kr_sidx[i]);
1356f48205beScasper return (NULL);
1357f48205beScasper }
1358f48205beScasper
1359f48205beScasper ksidlist_t *
crgetsidlist(const cred_t * cr)1360f48205beScasper crgetsidlist(const cred_t *cr)
1361f48205beScasper {
1362da6c28aaSamw if (cr->cr_ksid != NULL)
136328a151a0Scasper return (cr->cr_ksid->kr_sidlist);
1364f48205beScasper return (NULL);
1365f48205beScasper }
1366da6c28aaSamw
1367da6c28aaSamw /*
1368da6c28aaSamw * Interface to set the effective and permitted privileges for
1369da6c28aaSamw * a credential; this interface does no security checks and is
1370da6c28aaSamw * intended for kernel (file)servers creating credentials with
1371da6c28aaSamw * specific privileges.
1372da6c28aaSamw */
1373da6c28aaSamw int
crsetpriv(cred_t * cr,...)1374da6c28aaSamw crsetpriv(cred_t *cr, ...)
1375da6c28aaSamw {
1376da6c28aaSamw va_list ap;
1377da6c28aaSamw const char *privnm;
1378da6c28aaSamw
1379da6c28aaSamw ASSERT(cr->cr_ref <= 2);
1380da6c28aaSamw
1381da6c28aaSamw priv_set_PA(cr);
1382da6c28aaSamw
1383da6c28aaSamw va_start(ap, cr);
1384da6c28aaSamw
1385da6c28aaSamw while ((privnm = va_arg(ap, const char *)) != NULL) {
1386da6c28aaSamw int priv = priv_getbyname(privnm, 0);
1387da6c28aaSamw if (priv < 0)
1388da6c28aaSamw return (-1);
1389da6c28aaSamw
1390da6c28aaSamw priv_addset(&CR_PPRIV(cr), priv);
1391da6c28aaSamw priv_addset(&CR_EPRIV(cr), priv);
1392da6c28aaSamw }
1393da6c28aaSamw priv_adjust_PA(cr);
1394da6c28aaSamw va_end(ap);
1395da6c28aaSamw return (0);
1396da6c28aaSamw }
1397ddf7fe95Scasper
1398546a3997SThomas Haynes /*
1399546a3997SThomas Haynes * Interface to effectively set the PRIV_ALL for
1400546a3997SThomas Haynes * a credential; this interface does no security checks and is
1401546a3997SThomas Haynes * intended for kernel (file)servers to extend the user credentials
1402546a3997SThomas Haynes * to be ALL, like either kcred or zcred.
1403546a3997SThomas Haynes */
1404546a3997SThomas Haynes void
crset_zone_privall(cred_t * cr)1405546a3997SThomas Haynes crset_zone_privall(cred_t *cr)
1406546a3997SThomas Haynes {
1407546a3997SThomas Haynes zone_t *zone = crgetzone(cr);
1408546a3997SThomas Haynes
1409546a3997SThomas Haynes priv_fillset(&CR_LPRIV(cr));
1410546a3997SThomas Haynes CR_EPRIV(cr) = CR_PPRIV(cr) = CR_IPRIV(cr) = CR_LPRIV(cr);
1411546a3997SThomas Haynes priv_intersect(zone->zone_privset, &CR_LPRIV(cr));
1412546a3997SThomas Haynes priv_intersect(zone->zone_privset, &CR_EPRIV(cr));
1413546a3997SThomas Haynes priv_intersect(zone->zone_privset, &CR_IPRIV(cr));
1414546a3997SThomas Haynes priv_intersect(zone->zone_privset, &CR_PPRIV(cr));
1415546a3997SThomas Haynes }
1416546a3997SThomas Haynes
1417ddf7fe95Scasper struct credklpd *
crgetcrklpd(const cred_t * cr)1418ddf7fe95Scasper crgetcrklpd(const cred_t *cr)
1419ddf7fe95Scasper {
1420ddf7fe95Scasper return (cr->cr_klpd);
1421ddf7fe95Scasper }
1422ddf7fe95Scasper
1423ddf7fe95Scasper void
crsetcrklpd(cred_t * cr,struct credklpd * crklpd)1424ddf7fe95Scasper crsetcrklpd(cred_t *cr, struct credklpd *crklpd)
1425ddf7fe95Scasper {
1426ddf7fe95Scasper ASSERT(cr->cr_ref <= 2);
1427ddf7fe95Scasper
1428ddf7fe95Scasper if (cr->cr_klpd != NULL)
1429ddf7fe95Scasper crklpd_rele(cr->cr_klpd);
1430ddf7fe95Scasper cr->cr_klpd = crklpd;
1431ddf7fe95Scasper }
143267dbe2beSCasper H.S. Dik
143367dbe2beSCasper H.S. Dik credgrp_t *
crgrpcopyin(int n,gid_t * gidset)143467dbe2beSCasper H.S. Dik crgrpcopyin(int n, gid_t *gidset)
143567dbe2beSCasper H.S. Dik {
143667dbe2beSCasper H.S. Dik credgrp_t *mem;
143767dbe2beSCasper H.S. Dik size_t sz = CREDGRPSZ(n);
143867dbe2beSCasper H.S. Dik
143967dbe2beSCasper H.S. Dik ASSERT(n > 0);
144067dbe2beSCasper H.S. Dik
144167dbe2beSCasper H.S. Dik mem = kmem_alloc(sz, KM_SLEEP);
144267dbe2beSCasper H.S. Dik
144367dbe2beSCasper H.S. Dik if (copyin(gidset, mem->crg_groups, sizeof (gid_t) * n)) {
144467dbe2beSCasper H.S. Dik kmem_free(mem, sz);
144567dbe2beSCasper H.S. Dik return (NULL);
144667dbe2beSCasper H.S. Dik }
144767dbe2beSCasper H.S. Dik mem->crg_ref = 1;
144867dbe2beSCasper H.S. Dik mem->crg_ngroups = n;
1449b77dfcc8SIra Cooper qsort(mem->crg_groups, n, sizeof (gid_t), gidcmp);
145067dbe2beSCasper H.S. Dik return (mem);
145167dbe2beSCasper H.S. Dik }
145267dbe2beSCasper H.S. Dik
145367dbe2beSCasper H.S. Dik const gid_t *
crgetggroups(const credgrp_t * grps)145467dbe2beSCasper H.S. Dik crgetggroups(const credgrp_t *grps)
145567dbe2beSCasper H.S. Dik {
145667dbe2beSCasper H.S. Dik return (grps->crg_groups);
145767dbe2beSCasper H.S. Dik }
145867dbe2beSCasper H.S. Dik
145967dbe2beSCasper H.S. Dik void
crsetcredgrp(cred_t * cr,credgrp_t * grps)146067dbe2beSCasper H.S. Dik crsetcredgrp(cred_t *cr, credgrp_t *grps)
146167dbe2beSCasper H.S. Dik {
146267dbe2beSCasper H.S. Dik ASSERT(cr->cr_ref <= 2);
146367dbe2beSCasper H.S. Dik
146467dbe2beSCasper H.S. Dik if (cr->cr_grps != NULL)
146567dbe2beSCasper H.S. Dik crgrprele(cr->cr_grps);
146667dbe2beSCasper H.S. Dik
146767dbe2beSCasper H.S. Dik cr->cr_grps = grps;
146867dbe2beSCasper H.S. Dik }
146967dbe2beSCasper H.S. Dik
147067dbe2beSCasper H.S. Dik void
crgrprele(credgrp_t * grps)147167dbe2beSCasper H.S. Dik crgrprele(credgrp_t *grps)
147267dbe2beSCasper H.S. Dik {
14731a5e258fSJosef 'Jeff' Sipek if (atomic_dec_32_nv(&grps->crg_ref) == 0)
147467dbe2beSCasper H.S. Dik kmem_free(grps, CREDGRPSZ(grps->crg_ngroups));
147567dbe2beSCasper H.S. Dik }
147667dbe2beSCasper H.S. Dik
147767dbe2beSCasper H.S. Dik static void
crgrphold(credgrp_t * grps)147867dbe2beSCasper H.S. Dik crgrphold(credgrp_t *grps)
147967dbe2beSCasper H.S. Dik {
14801a5e258fSJosef 'Jeff' Sipek atomic_inc_32(&grps->crg_ref);
148167dbe2beSCasper H.S. Dik }
1482