]> CyberLeo.Net >> Repos - FreeBSD/FreeBSD.git/blob - sys/sys/jail.h
jail: Add pr_state to struct prison
[FreeBSD/FreeBSD.git] / sys / sys / jail.h
1 /*-
2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3  *
4  * Copyright (c) 1999 Poul-Henning Kamp.
5  * Copyright (c) 2009 James Gritton.
6  * All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27  * SUCH DAMAGE.
28  *
29  * $FreeBSD$
30  */
31
32 #ifndef _SYS_JAIL_H_
33 #define _SYS_JAIL_H_
34
35 #ifdef _KERNEL
36 struct jail_v0 {
37         u_int32_t       version;
38         char            *path;
39         char            *hostname;
40         u_int32_t       ip_number;
41 };
42 #endif
43
44 struct jail {
45         uint32_t        version;
46         char            *path;
47         char            *hostname;
48         char            *jailname;
49         uint32_t        ip4s;
50         uint32_t        ip6s;
51         struct in_addr  *ip4;
52         struct in6_addr *ip6;
53 };
54 #define JAIL_API_VERSION        2
55
56 /*
57  * For all xprison structs, always keep the pr_version an int and
58  * the first variable so userspace can easily distinguish them.
59  */
60 #ifndef _KERNEL
61 struct xprison_v1 {
62         int              pr_version;
63         int              pr_id;
64         char             pr_path[MAXPATHLEN];
65         char             pr_host[MAXHOSTNAMELEN];
66         u_int32_t        pr_ip;
67 };
68 #endif
69
70 struct xprison {
71         int              pr_version;
72         int              pr_id;
73         int              pr_state;
74         cpusetid_t       pr_cpusetid;
75         char             pr_path[MAXPATHLEN];
76         char             pr_host[MAXHOSTNAMELEN];
77         char             pr_name[MAXHOSTNAMELEN];
78         uint32_t         pr_ip4s;
79         uint32_t         pr_ip6s;
80 #if 0
81         /*
82          * sizeof(xprison) will be malloced + size needed for all
83          * IPv4 and IPv6 addesses. Offsets are based numbers of addresses.
84          */
85         struct in_addr   pr_ip4[];
86         struct in6_addr  pr_ip6[];
87 #endif
88 };
89 #define XPRISON_VERSION         3
90
91 enum prison_state {
92     PRISON_STATE_INVALID = 0,   /* New prison, not ready to be seen */
93     PRISON_STATE_ALIVE,         /* Current prison, visible to all */
94     PRISON_STATE_DYING          /* Removed but holding resources, */
95 };                              /* optionally visible. */
96
97 /*
98  * Flags for jail_set and jail_get.
99  */
100 #define JAIL_CREATE     0x01    /* Create jail if it doesn't exist */
101 #define JAIL_UPDATE     0x02    /* Update parameters of existing jail */
102 #define JAIL_ATTACH     0x04    /* Attach to jail upon creation */
103 #define JAIL_DYING      0x08    /* Allow getting a dying jail */
104 #define JAIL_SET_MASK   0x0f
105 #define JAIL_GET_MASK   0x08
106
107 #define JAIL_SYS_DISABLE        0
108 #define JAIL_SYS_NEW            1
109 #define JAIL_SYS_INHERIT        2
110
111 #ifndef _KERNEL
112
113 struct iovec;
114
115 __BEGIN_DECLS
116 int jail(struct jail *);
117 int jail_set(struct iovec *, unsigned int, int);
118 int jail_get(struct iovec *, unsigned int, int);
119 int jail_attach(int);
120 int jail_remove(int);
121 __END_DECLS
122
123 #else /* _KERNEL */
124
125 #include <sys/queue.h>
126 #include <sys/sysctl.h>
127 #include <sys/lock.h>
128 #include <sys/mutex.h>
129 #include <sys/_task.h>
130
131 #define JAIL_MAX        999999
132
133 #ifdef MALLOC_DECLARE
134 MALLOC_DECLARE(M_PRISON);
135 #endif
136 #endif /* _KERNEL */
137
138 #if defined(_KERNEL) || defined(_WANT_PRISON)
139
140 #include <sys/osd.h>
141
142 #define HOSTUUIDLEN     64
143 #define OSRELEASELEN    32
144
145 struct racct;
146 struct prison_racct;
147
148 /*
149  * This structure describes a prison.  It is pointed to by all struct
150  * ucreds's of the inmates.  pr_ref keeps track of them and is used to
151  * delete the struture when the last inmate is dead.
152  *
153  * Lock key:
154  *   (a) allprison_lock
155  *   (c) set only during creation before the structure is shared, no mutex
156  *       required to read
157  *   (m) locked by pr_mtx
158  *   (p) locked by pr_mtx, and also at least shared allprison_lock required
159  *       to update
160  *   (q) locked by both pr_mtx and allprison_lock
161  *   (r) atomic via refcount(9), pr_mtx and allprison_lock required to
162  *       decrement to zero
163  */
164 struct prison {
165         TAILQ_ENTRY(prison) pr_list;                    /* (a) all prisons */
166         int              pr_id;                         /* (c) prison id */
167         volatile u_int   pr_ref;                        /* (r) refcount */
168         volatile u_int   pr_uref;                       /* (r) user (alive) refcount */
169         unsigned         pr_flags;                      /* (p) PR_* flags */
170         LIST_HEAD(, prison) pr_children;                /* (a) list of child jails */
171         LIST_ENTRY(prison) pr_sibling;                  /* (a) next in parent's list */
172         struct prison   *pr_parent;                     /* (c) containing jail */
173         struct mtx       pr_mtx;
174         struct task      pr_task;                       /* (c) destroy task */
175         struct osd       pr_osd;                        /* (p) additional data */
176         struct cpuset   *pr_cpuset;                     /* (p) cpuset */
177         struct vnet     *pr_vnet;                       /* (c) network stack */
178         struct vnode    *pr_root;                       /* (c) vnode to rdir */
179         int              pr_ip4s;                       /* (p) number of v4 IPs */
180         int              pr_ip6s;                       /* (p) number of v6 IPs */
181         struct in_addr  *pr_ip4;                        /* (p) v4 IPs of jail */
182         struct in6_addr *pr_ip6;                        /* (p) v6 IPs of jail */
183         struct prison_racct *pr_prison_racct;           /* (c) racct jail proxy */
184         void            *pr_sparep[3];
185         int              pr_childcount;                 /* (a) number of child jails */
186         int              pr_childmax;                   /* (p) maximum child jails */
187         unsigned         pr_allow;                      /* (p) PR_ALLOW_* flags */
188         int              pr_securelevel;                /* (p) securelevel */
189         int              pr_enforce_statfs;             /* (p) statfs permission */
190         int              pr_devfs_rsnum;                /* (p) devfs ruleset */
191         enum prison_state pr_state;                     /* (q) state in life cycle */
192         int              pr_spare[2];
193         int              pr_osreldate;                  /* (c) kern.osreldate value */
194         unsigned long    pr_hostid;                     /* (p) jail hostid */
195         char             pr_name[MAXHOSTNAMELEN];       /* (p) admin jail name */
196         char             pr_path[MAXPATHLEN];           /* (c) chroot path */
197         char             pr_hostname[MAXHOSTNAMELEN];   /* (p) jail hostname */
198         char             pr_domainname[MAXHOSTNAMELEN]; /* (p) jail domainname */
199         char             pr_hostuuid[HOSTUUIDLEN];      /* (p) jail hostuuid */
200         char             pr_osrelease[OSRELEASELEN];    /* (c) kern.osrelease value */
201 };
202
203 struct prison_racct {
204         LIST_ENTRY(prison_racct) prr_next;
205         char            prr_name[MAXHOSTNAMELEN];
206         u_int           prr_refcount;
207         struct racct    *prr_racct;
208 };
209 #endif /* _KERNEL || _WANT_PRISON */
210
211 #ifdef _KERNEL
212 /* Flag bits set via options */
213 #define PR_PERSIST      0x00000001      /* Can exist without processes */
214 #define PR_HOST         0x00000002      /* Virtualize hostname et al */
215 #define PR_IP4_USER     0x00000004      /* Restrict IPv4 addresses */
216 #define PR_IP6_USER     0x00000008      /* Restrict IPv6 addresses */
217 #define PR_VNET         0x00000010      /* Virtual network stack */
218 #define PR_IP4_SADDRSEL 0x00000080      /* Do IPv4 src addr sel. or use the */
219                                         /* primary jail address. */
220 #define PR_IP6_SADDRSEL 0x00000100      /* Do IPv6 src addr sel. or use the */
221                                         /* primary jail address. */
222
223 /* Internal flag bits */
224 #define PR_REMOVE       0x01000000      /* In process of being removed */
225 #define PR_IP4          0x02000000      /* IPv4 restricted or disabled */
226                                         /* by this jail or an ancestor */
227 #define PR_IP6          0x04000000      /* IPv6 restricted or disabled */
228                                         /* by this jail or an ancestor */
229 #define PR_COMPLETE_PROC 0x08000000     /* prison_complete called from */
230                                         /* prison_proc_free, releases uref */
231
232 /*
233  * Flags for pr_allow
234  * Bits not noted here may be used for dynamic allow.mount.xxxfs.
235  */
236 #define PR_ALLOW_SET_HOSTNAME           0x00000001
237 #define PR_ALLOW_SYSVIPC                0x00000002
238 #define PR_ALLOW_RAW_SOCKETS            0x00000004
239 #define PR_ALLOW_CHFLAGS                0x00000008
240 #define PR_ALLOW_MOUNT                  0x00000010
241 #define PR_ALLOW_QUOTAS                 0x00000020
242 #define PR_ALLOW_SOCKET_AF              0x00000040
243 #define PR_ALLOW_MLOCK                  0x00000080
244 #define PR_ALLOW_READ_MSGBUF            0x00000100
245 #define PR_ALLOW_UNPRIV_DEBUG           0x00000200
246 #define PR_ALLOW_SUSER                  0x00000400
247 #define PR_ALLOW_RESERVED_PORTS         0x00008000
248 #define PR_ALLOW_KMEM_ACCESS            0x00010000      /* reserved, not used yet */
249 #define PR_ALLOW_ALL_STATIC             0x000187ff
250
251 /*
252  * PR_ALLOW_DIFFERENCES determines which flags are able to be
253  * different between the parent and child jail upon creation.
254  */
255 #define PR_ALLOW_DIFFERENCES            (PR_ALLOW_UNPRIV_DEBUG)
256
257 /*
258  * OSD methods
259  */
260 #define PR_METHOD_CREATE        0
261 #define PR_METHOD_GET           1
262 #define PR_METHOD_SET           2
263 #define PR_METHOD_CHECK         3
264 #define PR_METHOD_ATTACH        4
265 #define PR_METHOD_REMOVE        5
266 #define PR_MAXMETHOD            6
267
268 /*
269  * Lock/unlock a prison.
270  * XXX These exist not so much for general convenience, but to be useable in
271  *     the FOREACH_PRISON_DESCENDANT_LOCKED macro which can't handle them in
272  *     non-function form as currently defined.
273  */
274 static __inline void
275 prison_lock(struct prison *pr)
276 {
277
278         mtx_lock(&pr->pr_mtx);
279 }
280
281 static __inline void
282 prison_unlock(struct prison *pr)
283 {
284
285         mtx_unlock(&pr->pr_mtx);
286 }
287
288 /* Traverse a prison's immediate children. */
289 #define FOREACH_PRISON_CHILD(ppr, cpr)                                  \
290         LIST_FOREACH(cpr, &(ppr)->pr_children, pr_sibling)
291
292 /*
293  * Preorder traversal of all of a prison's descendants.
294  * This ugly loop allows the macro to be followed by a single block
295  * as expected in a looping primitive.
296  */
297 #define FOREACH_PRISON_DESCENDANT(ppr, cpr, descend)                    \
298         for ((cpr) = (ppr), (descend) = 1;                              \
299             ((cpr) = (((descend) && !LIST_EMPTY(&(cpr)->pr_children))   \
300               ? LIST_FIRST(&(cpr)->pr_children)                         \
301               : ((cpr) == (ppr)                                         \
302                  ? NULL                                                 \
303                  : (((descend) = LIST_NEXT(cpr, pr_sibling) != NULL)    \
304                     ? LIST_NEXT(cpr, pr_sibling)                        \
305                     : (cpr)->pr_parent))));)                            \
306                 if (!(descend))                                         \
307                         ;                                               \
308                 else
309
310 /*
311  * As above, but lock descendants on the way down and unlock on the way up.
312  */
313 #define FOREACH_PRISON_DESCENDANT_LOCKED(ppr, cpr, descend)             \
314         for ((cpr) = (ppr), (descend) = 1;                              \
315             ((cpr) = (((descend) && !LIST_EMPTY(&(cpr)->pr_children))   \
316               ? LIST_FIRST(&(cpr)->pr_children)                         \
317               : ((cpr) == (ppr)                                         \
318                  ? NULL                                                 \
319                  : ((prison_unlock(cpr),                                \
320                     (descend) = LIST_NEXT(cpr, pr_sibling) != NULL)     \
321                     ? LIST_NEXT(cpr, pr_sibling)                        \
322                     : (cpr)->pr_parent))));)                            \
323                 if ((descend) ? (prison_lock(cpr), 0) : 1)              \
324                         ;                                               \
325                 else
326
327 /*
328  * As above, but also keep track of the level descended to.
329  */
330 #define FOREACH_PRISON_DESCENDANT_LOCKED_LEVEL(ppr, cpr, descend, level)\
331         for ((cpr) = (ppr), (descend) = 1, (level) = 0;                 \
332             ((cpr) = (((descend) && !LIST_EMPTY(&(cpr)->pr_children))   \
333               ? (level++, LIST_FIRST(&(cpr)->pr_children))              \
334               : ((cpr) == (ppr)                                         \
335                  ? NULL                                                 \
336                  : ((prison_unlock(cpr),                                \
337                     (descend) = LIST_NEXT(cpr, pr_sibling) != NULL)     \
338                     ? LIST_NEXT(cpr, pr_sibling)                        \
339                     : (level--, (cpr)->pr_parent)))));)                 \
340                 if ((descend) ? (prison_lock(cpr), 0) : 1)              \
341                         ;                                               \
342                 else
343
344 /*
345  * Attributes of the physical system, and the root of the jail tree.
346  */
347 extern struct   prison prison0;
348
349 TAILQ_HEAD(prisonlist, prison);
350 extern struct   prisonlist allprison;
351 extern struct   sx allprison_lock;
352
353 /*
354  * Sysctls to describe jail parameters.
355  */
356 SYSCTL_DECL(_security_jail_param);
357
358 #define SYSCTL_JAIL_PARAM(module, param, type, fmt, descr)              \
359     SYSCTL_PROC(_security_jail_param ## module, OID_AUTO, param,        \
360         (type) | CTLFLAG_MPSAFE, NULL, 0, sysctl_jail_param, fmt, descr)
361 #define SYSCTL_JAIL_PARAM_STRING(module, param, access, len, descr)     \
362     SYSCTL_PROC(_security_jail_param ## module, OID_AUTO, param,        \
363         CTLTYPE_STRING | CTLFLAG_MPSAFE | (access), NULL, len,          \
364         sysctl_jail_param, "A", descr)
365 #define SYSCTL_JAIL_PARAM_STRUCT(module, param, access, len, fmt, descr)\
366     SYSCTL_PROC(_security_jail_param ## module, OID_AUTO, param,        \
367         CTLTYPE_STRUCT | CTLFLAG_MPSAFE | (access), NULL, len,          \
368         sysctl_jail_param, fmt, descr)
369 #define SYSCTL_JAIL_PARAM_NODE(module, descr)                           \
370     SYSCTL_NODE(_security_jail_param, OID_AUTO, module, CTLFLAG_MPSAFE, \
371         0, descr)
372 #define SYSCTL_JAIL_PARAM_SUBNODE(parent, module, descr)                \
373     SYSCTL_NODE(_security_jail_param_##parent, OID_AUTO, module,        \
374         CTLFLAG_MPSAFE, 0, descr)
375 #define SYSCTL_JAIL_PARAM_SYS_NODE(module, access, descr)               \
376     SYSCTL_JAIL_PARAM_NODE(module, descr);                              \
377     SYSCTL_JAIL_PARAM(_##module, , CTLTYPE_INT | (access), "E,jailsys", \
378         descr)
379
380 /*
381  * Kernel support functions for jail().
382  */
383 struct ucred;
384 struct mount;
385 struct sockaddr;
386 struct statfs;
387 struct vfsconf;
388
389 /*
390  * Return 1 if the passed credential is in a jail, otherwise 0.
391  */
392 #define jailed(cred)    (cred->cr_prison != &prison0)
393
394 int jailed_without_vnet(struct ucred *);
395 void getcredhostname(struct ucred *, char *, size_t);
396 void getcreddomainname(struct ucred *, char *, size_t);
397 void getcredhostuuid(struct ucred *, char *, size_t);
398 void getcredhostid(struct ucred *, unsigned long *);
399 void getjailname(struct ucred *cred, char *name, size_t len);
400 void prison0_init(void);
401 int prison_allow(struct ucred *, unsigned);
402 int prison_check(struct ucred *cred1, struct ucred *cred2);
403 int prison_owns_vnet(struct ucred *);
404 int prison_canseemount(struct ucred *cred, struct mount *mp);
405 void prison_enforce_statfs(struct ucred *cred, struct mount *mp,
406     struct statfs *sp);
407 struct prison *prison_find(int prid);
408 struct prison *prison_find_child(struct prison *, int);
409 struct prison *prison_find_name(struct prison *, const char *);
410 int prison_flag(struct ucred *, unsigned);
411 void prison_free(struct prison *pr);
412 void prison_free_locked(struct prison *pr);
413 void prison_hold(struct prison *pr);
414 void prison_hold_locked(struct prison *pr);
415 void prison_proc_hold(struct prison *);
416 void prison_proc_free(struct prison *);
417 void prison_set_allow(struct ucred *cred, unsigned flag, int enable);
418 int prison_ischild(struct prison *, struct prison *);
419 bool prison_isalive(struct prison *);
420 bool prison_isvalid(struct prison *);
421 int prison_equal_ip4(struct prison *, struct prison *);
422 int prison_get_ip4(struct ucred *cred, struct in_addr *ia);
423 int prison_local_ip4(struct ucred *cred, struct in_addr *ia);
424 int prison_remote_ip4(struct ucred *cred, struct in_addr *ia);
425 int prison_check_ip4(const struct ucred *, const struct in_addr *);
426 int prison_check_ip4_locked(const struct prison *, const struct in_addr *);
427 int prison_saddrsel_ip4(struct ucred *, struct in_addr *);
428 int prison_restrict_ip4(struct prison *, struct in_addr *);
429 int prison_qcmp_v4(const void *, const void *);
430 #ifdef INET6
431 int prison_equal_ip6(struct prison *, struct prison *);
432 int prison_get_ip6(struct ucred *, struct in6_addr *);
433 int prison_local_ip6(struct ucred *, struct in6_addr *, int);
434 int prison_remote_ip6(struct ucred *, struct in6_addr *);
435 int prison_check_ip6(const struct ucred *, const struct in6_addr *);
436 int prison_check_ip6_locked(const struct prison *, const struct in6_addr *);
437 int prison_saddrsel_ip6(struct ucred *, struct in6_addr *);
438 int prison_restrict_ip6(struct prison *, struct in6_addr *);
439 int prison_qcmp_v6(const void *, const void *);
440 #endif
441 int prison_check_af(struct ucred *cred, int af);
442 int prison_if(struct ucred *cred, const struct sockaddr *sa);
443 char *prison_name(struct prison *, struct prison *);
444 int prison_priv_check(struct ucred *cred, int priv);
445 int sysctl_jail_param(SYSCTL_HANDLER_ARGS);
446 unsigned prison_add_allow(const char *prefix, const char *name,
447     const char *prefix_descr, const char *descr);
448 void prison_add_vfs(struct vfsconf *vfsp);
449 void prison_racct_foreach(void (*callback)(struct racct *racct,
450     void *arg2, void *arg3), void (*pre)(void), void (*post)(void),
451     void *arg2, void *arg3);
452 struct prison_racct *prison_racct_find(const char *name);
453 void prison_racct_hold(struct prison_racct *prr);
454 void prison_racct_free(struct prison_racct *prr);
455
456 #endif /* _KERNEL */
457 #endif /* !_SYS_JAIL_H_ */