sys/kern/kern_jail.c

   1 /*-
   2  * ----------------------------------------------------------------------------
   3  * "THE BEER-WARE LICENSE" (Revision 42):
   4  * <phk@FreeBSD.ORG> wrote this file.  As long as you retain this notice you
   5  * can do whatever you want with this stuff. If we meet some day, and you think
   6  * this stuff is worth it, you can buy me a beer in return.   Poul-Henning Kamp
   7  * ----------------------------------------------------------------------------
   8  */
   9
  10 #include <sys/cdefs.h>
  11 __FBSDID("$FreeBSD$");
  12
  13 #include "opt_mac.h"
  14
  15 #include <sys/param.h>
  16 #include <sys/types.h>
  17 #include <sys/kernel.h>
  18 #include <sys/systm.h>
  19 #include <sys/errno.h>
  20 #include <sys/sysproto.h>
  21 #include <sys/malloc.h>
  22 #include <sys/priv.h>
  23 #include <sys/proc.h>
  24 #include <sys/taskqueue.h>
  25 #include <sys/jail.h>
  26 #include <sys/lock.h>
  27 #include <sys/mutex.h>
  28 #include <sys/namei.h>
  29 #include <sys/mount.h>
  30 #include <sys/queue.h>
  31 #include <sys/socket.h>
  32 #include <sys/syscallsubr.h>
  33 #include <sys/sysctl.h>
  34 #include <sys/vnode.h>
  35 #include <net/if.h>
  36 #include <netinet/in.h>
  37
  38 #include <security/mac/mac_framework.h>
  39
  40 MALLOC_DEFINE(M_PRISON, "prison", "Prison structures");
  41
  42 SYSCTL_NODE(_security, OID_AUTO, jail, CTLFLAG_RW, 0,
  43     "Jail rules");
  44
  45 int     jail_set_hostname_allowed = 1;
  46 SYSCTL_INT(_security_jail, OID_AUTO, set_hostname_allowed, CTLFLAG_RW,
  47     &jail_set_hostname_allowed, 0,
  48     "Processes in jail can set their hostnames");
  49
  50 int     jail_socket_unixiproute_only = 1;
  51 SYSCTL_INT(_security_jail, OID_AUTO, socket_unixiproute_only, CTLFLAG_RW,
  52     &jail_socket_unixiproute_only, 0,
  53     "Processes in jail are limited to creating UNIX/IPv4/route sockets only");
  54
  55 int     jail_sysvipc_allowed = 0;
  56 SYSCTL_INT(_security_jail, OID_AUTO, sysvipc_allowed, CTLFLAG_RW,
  57     &jail_sysvipc_allowed, 0,
  58     "Processes in jail can use System V IPC primitives");
  59
  60 static int jail_enforce_statfs = 2;
  61 SYSCTL_INT(_security_jail, OID_AUTO, enforce_statfs, CTLFLAG_RW,
  62     &jail_enforce_statfs, 0,
  63     "Processes in jail cannot see all mounted file systems");
  64
  65 int     jail_allow_raw_sockets = 0;
  66 SYSCTL_INT(_security_jail, OID_AUTO, allow_raw_sockets, CTLFLAG_RW,
  67     &jail_allow_raw_sockets, 0,
  68     "Prison root can create raw sockets");
  69
  70 int     jail_chflags_allowed = 0;
  71 SYSCTL_INT(_security_jail, OID_AUTO, chflags_allowed, CTLFLAG_RW,
  72     &jail_chflags_allowed, 0,
  73     "Processes in jail can alter system file flags");
  74
  75 /* allprison, lastprid, and prisoncount are protected by allprison_mtx. */
  76 struct  prisonlist allprison;
  77 struct  mtx allprison_mtx;
  78 int     lastprid = 0;
  79 int     prisoncount = 0;
  80
  81 static void              init_prison(void *);
  82 static void              prison_complete(void *context, int pending);
  83 static struct prison    *prison_find(int);
  84 static int               sysctl_jail_list(SYSCTL_HANDLER_ARGS);
  85
  86 static void
  87 init_prison(void *data __unused)
  88 {
  89
  90         mtx_init(&allprison_mtx, "allprison", NULL, MTX_DEF);
  91         LIST_INIT(&allprison);
  92 }
  93
  94 SYSINIT(prison, SI_SUB_INTRINSIC, SI_ORDER_ANY, init_prison, NULL);
  95
  96 /*
  97  * MPSAFE
  98  *
  99  * struct jail_args {
 100  *      struct jail *jail;
 101  * };
 102  */
 103 int
 104 jail(struct thread *td, struct jail_args *uap)
 105 {
 106         struct nameidata nd;
 107         struct prison *pr, *tpr;
 108         struct jail j;
 109         struct jail_attach_args jaa;
 110         int vfslocked, error, tryprid;
 111
 112         error = copyin(uap->jail, &j, sizeof(j));
 113         if (error)
 114                 return (error);
 115         if (j.version != 0)
 116                 return (EINVAL);
 117
 118         MALLOC(pr, struct prison *, sizeof(*pr), M_PRISON, M_WAITOK | M_ZERO);
 119         mtx_init(&pr->pr_mtx, "jail mutex", NULL, MTX_DEF);
 120         pr->pr_ref = 1;
 121         error = copyinstr(j.path, &pr->pr_path, sizeof(pr->pr_path), 0);
 122         if (error)
 123                 goto e_killmtx;
 124         NDINIT(&nd, LOOKUP, MPSAFE | FOLLOW | LOCKLEAF, UIO_SYSSPACE,
 125             pr->pr_path, td);
 126         error = namei(&nd);
 127         if (error)
 128                 goto e_killmtx;
 129         vfslocked = NDHASGIANT(&nd);
 130         pr->pr_root = nd.ni_vp;
 131         VOP_UNLOCK(nd.ni_vp, 0, td);
 132         NDFREE(&nd, NDF_ONLY_PNBUF);
 133         VFS_UNLOCK_GIANT(vfslocked);
 134         error = copyinstr(j.hostname, &pr->pr_host, sizeof(pr->pr_host), 0);
 135         if (error)
 136                 goto e_dropvnref;
 137         pr->pr_ip = j.ip_number;
 138         pr->pr_linux = NULL;
 139         pr->pr_securelevel = securelevel;
 140
 141         /* Determine next pr_id and add prison to allprison list. */
 142         mtx_lock(&allprison_mtx);
 143         tryprid = lastprid + 1;
 144         if (tryprid == JAIL_MAX)
 145                 tryprid = 1;
 146 next:
 147         LIST_FOREACH(tpr, &allprison, pr_list) {
 148                 if (tpr->pr_id == tryprid) {
 149                         tryprid++;
 150                         if (tryprid == JAIL_MAX) {
 151                                 mtx_unlock(&allprison_mtx);
 152                                 error = EAGAIN;
 153                                 goto e_dropvnref;
 154                         }
 155                         goto next;
 156                 }
 157         }
 158         pr->pr_id = jaa.jid = lastprid = tryprid;
 159         LIST_INSERT_HEAD(&allprison, pr, pr_list);
 160         prisoncount++;
 161         mtx_unlock(&allprison_mtx);
 162
 163         error = jail_attach(td, &jaa);
 164         if (error)
 165                 goto e_dropprref;
 166         mtx_lock(&pr->pr_mtx);
 167         pr->pr_ref--;
 168         mtx_unlock(&pr->pr_mtx);
 169         td->td_retval[0] = jaa.jid;
 170         return (0);
 171 e_dropprref:
 172         mtx_lock(&allprison_mtx);
 173         LIST_REMOVE(pr, pr_list);
 174         prisoncount--;
 175         mtx_unlock(&allprison_mtx);
 176 e_dropvnref:
 177         vfslocked = VFS_LOCK_GIANT(pr->pr_root->v_mount);
 178         vrele(pr->pr_root);
 179         VFS_UNLOCK_GIANT(vfslocked);
 180 e_killmtx:
 181         mtx_destroy(&pr->pr_mtx);
 182         FREE(pr, M_PRISON);
 183         return (error);
 184 }
 185
 186 /*
 187  * MPSAFE
 188  *
 189  * struct jail_attach_args {
 190  *      int jid;
 191  * };
 192  */
 193 int
 194 jail_attach(struct thread *td, struct jail_attach_args *uap)
 195 {
 196         struct proc *p;
 197         struct ucred *newcred, *oldcred;
 198         struct prison *pr;
 199         int vfslocked, error;
 200
 201         /*
 202          * XXX: Note that there is a slight race here if two threads
 203          * in the same privileged process attempt to attach to two
 204          * different jails at the same time.  It is important for
 205          * user processes not to do this, or they might end up with
 206          * a process root from one prison, but attached to the jail
 207          * of another.
 208          */
 209         error = priv_check(td, PRIV_JAIL_ATTACH);
 210         if (error)
 211                 return (error);
 212
 213         p = td->td_proc;
 214         mtx_lock(&allprison_mtx);
 215         pr = prison_find(uap->jid);
 216         if (pr == NULL) {
 217                 mtx_unlock(&allprison_mtx);
 218                 return (EINVAL);
 219         }
 220         pr->pr_ref++;
 221         mtx_unlock(&pr->pr_mtx);
 222         mtx_unlock(&allprison_mtx);
 223
 224         vfslocked = VFS_LOCK_GIANT(pr->pr_root->v_mount);
 225         vn_lock(pr->pr_root, LK_EXCLUSIVE | LK_RETRY, td);
 226         if ((error = change_dir(pr->pr_root, td)) != 0)
 227                 goto e_unlock;
 228 #ifdef MAC
 229         if ((error = mac_check_vnode_chroot(td->td_ucred, pr->pr_root)))
 230                 goto e_unlock;
 231 #endif
 232         VOP_UNLOCK(pr->pr_root, 0, td);
 233         change_root(pr->pr_root, td);
 234         VFS_UNLOCK_GIANT(vfslocked);
 235
 236         newcred = crget();
 237         PROC_LOCK(p);
 238         oldcred = p->p_ucred;
 239         setsugid(p);
 240         crcopy(newcred, oldcred);
 241         newcred->cr_prison = pr;
 242         p->p_ucred = newcred;
 243         PROC_UNLOCK(p);
 244         crfree(oldcred);
 245         return (0);
 246 e_unlock:
 247         VOP_UNLOCK(pr->pr_root, 0, td);
 248         VFS_UNLOCK_GIANT(vfslocked);
 249         mtx_lock(&pr->pr_mtx);
 250         pr->pr_ref--;
 251         mtx_unlock(&pr->pr_mtx);
 252         return (error);
 253 }
 254
 255 /*
 256  * Returns a locked prison instance, or NULL on failure.
 257  */
 258 static struct prison *
 259 prison_find(int prid)
 260 {
 261         struct prison *pr;
 262
 263         mtx_assert(&allprison_mtx, MA_OWNED);
 264         LIST_FOREACH(pr, &allprison, pr_list) {
 265                 if (pr->pr_id == prid) {
 266                         mtx_lock(&pr->pr_mtx);
 267                         return (pr);
 268                 }
 269         }
 270         return (NULL);
 271 }
 272
 273 void
 274 prison_free(struct prison *pr)
 275 {
 276
 277         mtx_lock(&allprison_mtx);
 278         mtx_lock(&pr->pr_mtx);
 279         pr->pr_ref--;
 280         if (pr->pr_ref == 0) {
 281                 LIST_REMOVE(pr, pr_list);
 282                 mtx_unlock(&pr->pr_mtx);
 283                 prisoncount--;
 284                 mtx_unlock(&allprison_mtx);
 285
 286                 TASK_INIT(&pr->pr_task, 0, prison_complete, pr);
 287                 taskqueue_enqueue(taskqueue_thread, &pr->pr_task);
 288                 return;
 289         }
 290         mtx_unlock(&pr->pr_mtx);
 291         mtx_unlock(&allprison_mtx);
 292 }
 293
 294 static void
 295 prison_complete(void *context, int pending)
 296 {
 297         struct prison *pr;
 298         int vfslocked;
 299
 300         pr = (struct prison *)context;
 301
 302         vfslocked = VFS_LOCK_GIANT(pr->pr_root->v_mount);
 303         vrele(pr->pr_root);
 304         VFS_UNLOCK_GIANT(vfslocked);
 305
 306         mtx_destroy(&pr->pr_mtx);
 307         if (pr->pr_linux != NULL)
 308                 FREE(pr->pr_linux, M_PRISON);
 309         FREE(pr, M_PRISON);
 310 }
 311
 312 void
 313 prison_hold(struct prison *pr)
 314 {
 315
 316         mtx_lock(&pr->pr_mtx);
 317         pr->pr_ref++;
 318         mtx_unlock(&pr->pr_mtx);
 319 }
 320
 321 u_int32_t
 322 prison_getip(struct ucred *cred)
 323 {
 324
 325         return (cred->cr_prison->pr_ip);
 326 }
 327
 328 int
 329 prison_ip(struct ucred *cred, int flag, u_int32_t *ip)
 330 {
 331         u_int32_t tmp;
 332
 333         if (!jailed(cred))
 334                 return (0);
 335         if (flag)
 336                 tmp = *ip;
 337         else
 338                 tmp = ntohl(*ip);
 339         if (tmp == INADDR_ANY) {
 340                 if (flag)
 341                         *ip = cred->cr_prison->pr_ip;
 342                 else
 343                         *ip = htonl(cred->cr_prison->pr_ip);
 344                 return (0);
 345         }
 346         if (tmp == INADDR_LOOPBACK) {
 347                 if (flag)
 348                         *ip = cred->cr_prison->pr_ip;
 349                 else
 350                         *ip = htonl(cred->cr_prison->pr_ip);
 351                 return (0);
 352         }
 353         if (cred->cr_prison->pr_ip != tmp)
 354                 return (1);
 355         return (0);
 356 }
 357
 358 void
 359 prison_remote_ip(struct ucred *cred, int flag, u_int32_t *ip)
 360 {
 361         u_int32_t tmp;
 362
 363         if (!jailed(cred))
 364                 return;
 365         if (flag)
 366                 tmp = *ip;
 367         else
 368                 tmp = ntohl(*ip);
 369         if (tmp == INADDR_LOOPBACK) {
 370                 if (flag)
 371                         *ip = cred->cr_prison->pr_ip;
 372                 else
 373                         *ip = htonl(cred->cr_prison->pr_ip);
 374                 return;
 375         }
 376         return;
 377 }
 378
 379 int
 380 prison_if(struct ucred *cred, struct sockaddr *sa)
 381 {
 382         struct sockaddr_in *sai;
 383         int ok;
 384
 385         sai = (struct sockaddr_in *)sa;
 386         if ((sai->sin_family != AF_INET) && jail_socket_unixiproute_only)
 387                 ok = 1;
 388         else if (sai->sin_family != AF_INET)
 389                 ok = 0;
 390         else if (cred->cr_prison->pr_ip != ntohl(sai->sin_addr.s_addr))
 391                 ok = 1;
 392         else
 393                 ok = 0;
 394         return (ok);
 395 }
 396
 397 /*
 398  * Return 0 if jails permit p1 to frob p2, otherwise ESRCH.
 399  */
 400 int
 401 prison_check(struct ucred *cred1, struct ucred *cred2)
 402 {
 403
 404         if (jailed(cred1)) {
 405                 if (!jailed(cred2))
 406                         return (ESRCH);
 407                 if (cred2->cr_prison != cred1->cr_prison)
 408                         return (ESRCH);
 409         }
 410
 411         return (0);
 412 }
 413
 414 /*
 415  * Return 1 if the passed credential is in a jail, otherwise 0.
 416  */
 417 int
 418 jailed(struct ucred *cred)
 419 {
 420
 421         return (cred->cr_prison != NULL);
 422 }
 423
 424 /*
 425  * Return the correct hostname for the passed credential.
 426  */
 427 void
 428 getcredhostname(struct ucred *cred, char *buf, size_t size)
 429 {
 430
 431         if (jailed(cred)) {
 432                 mtx_lock(&cred->cr_prison->pr_mtx);
 433                 strlcpy(buf, cred->cr_prison->pr_host, size);
 434                 mtx_unlock(&cred->cr_prison->pr_mtx);
 435         } else
 436                 strlcpy(buf, hostname, size);
 437 }
 438
 439 /*
 440  * Determine whether the subject represented by cred can "see"
 441  * status of a mount point.
 442  * Returns: 0 for permitted, ENOENT otherwise.
 443  * XXX: This function should be called cr_canseemount() and should be
 444  *      placed in kern_prot.c.
 445  */
 446 int
 447 prison_canseemount(struct ucred *cred, struct mount *mp)
 448 {
 449         struct prison *pr;
 450         struct statfs *sp;
 451         size_t len;
 452
 453         if (!jailed(cred) || jail_enforce_statfs == 0)
 454                 return (0);
 455         pr = cred->cr_prison;
 456         if (pr->pr_root->v_mount == mp)
 457                 return (0);
 458         if (jail_enforce_statfs == 2)
 459                 return (ENOENT);
 460         /*
 461          * If jail's chroot directory is set to "/" we should be able to see
 462          * all mount-points from inside a jail.
 463          * This is ugly check, but this is the only situation when jail's
 464          * directory ends with '/'.
 465          */
 466         if (strcmp(pr->pr_path, "/") == 0)
 467                 return (0);
 468         len = strlen(pr->pr_path);
 469         sp = &mp->mnt_stat;
 470         if (strncmp(pr->pr_path, sp->f_mntonname, len) != 0)
 471                 return (ENOENT);
 472         /*
 473          * Be sure that we don't have situation where jail's root directory
 474          * is "/some/path" and mount point is "/some/pathpath".
 475          */
 476         if (sp->f_mntonname[len] != '\0' && sp->f_mntonname[len] != '/')
 477                 return (ENOENT);
 478         return (0);
 479 }
 480
 481 void
 482 prison_enforce_statfs(struct ucred *cred, struct mount *mp, struct statfs *sp)
 483 {
 484         char jpath[MAXPATHLEN];
 485         struct prison *pr;
 486         size_t len;
 487
 488         if (!jailed(cred) || jail_enforce_statfs == 0)
 489                 return;
 490         pr = cred->cr_prison;
 491         if (prison_canseemount(cred, mp) != 0) {
 492                 bzero(sp->f_mntonname, sizeof(sp->f_mntonname));
 493                 strlcpy(sp->f_mntonname, "[restricted]",
 494                     sizeof(sp->f_mntonname));
 495                 return;
 496         }
 497         if (pr->pr_root->v_mount == mp) {
 498                 /*
 499                  * Clear current buffer data, so we are sure nothing from
 500                  * the valid path left there.
 501                  */
 502                 bzero(sp->f_mntonname, sizeof(sp->f_mntonname));
 503                 *sp->f_mntonname = '/';
 504                 return;
 505         }
 506         /*
 507          * If jail's chroot directory is set to "/" we should be able to see
 508          * all mount-points from inside a jail.
 509          */
 510         if (strcmp(pr->pr_path, "/") == 0)
 511                 return;
 512         len = strlen(pr->pr_path);
 513         strlcpy(jpath, sp->f_mntonname + len, sizeof(jpath));
 514         /*
 515          * Clear current buffer data, so we are sure nothing from
 516          * the valid path left there.
 517          */
 518         bzero(sp->f_mntonname, sizeof(sp->f_mntonname));
 519         if (*jpath == '\0') {
 520                 /* Should never happen. */
 521                 *sp->f_mntonname = '/';
 522         } else {
 523                 strlcpy(sp->f_mntonname, jpath, sizeof(sp->f_mntonname));
 524         }
 525 }
 526
 527 /*
 528  * Check with permission for a specific privilege is granted within jail.  We
 529  * have a specific list of accepted privileges; the rest are denied.
 530  */
 531 int
 532 prison_priv_check(struct ucred *cred, int priv)
 533 {
 534
 535         if (!jailed(cred))
 536                 return (0);
 537
 538         switch (priv) {
 539
 540                 /*
 541                  * Allow ktrace privileges for root in jail.
 542                  */
 543         case PRIV_KTRACE:
 544
 545                 /*
 546                  * Allow jailed processes to configure audit identity and
 547                  * submit audit records (login, etc).  In the future we may
 548                  * want to further refine the relationship between audit and
 549                  * jail.
 550                  */
 551         case PRIV_AUDIT_GETAUDIT:
 552         case PRIV_AUDIT_SETAUDIT:
 553         case PRIV_AUDIT_SUBMIT:
 554
 555                 /*
 556                  * Allow jailed processes to manipulate process UNIX
 557                  * credentials in any way they see fit.
 558                  */
 559         case PRIV_CRED_SETUID:
 560         case PRIV_CRED_SETEUID:
 561         case PRIV_CRED_SETGID:
 562         case PRIV_CRED_SETEGID:
 563         case PRIV_CRED_SETGROUPS:
 564         case PRIV_CRED_SETREUID:
 565         case PRIV_CRED_SETREGID:
 566         case PRIV_CRED_SETRESUID:
 567         case PRIV_CRED_SETRESGID:
 568
 569                 /*
 570                  * Jail implements visibility constraints already, so allow
 571                  * jailed root to override uid/gid-based constraints.
 572                  */
 573         case PRIV_SEEOTHERGIDS:
 574         case PRIV_SEEOTHERUIDS:
 575
 576                 /*
 577                  * Jail implements inter-process debugging limits already, so
 578                  * allow jailed root various debugging privileges.
 579                  */
 580         case PRIV_DEBUG_DIFFCRED:
 581         case PRIV_DEBUG_SUGID:
 582         case PRIV_DEBUG_UNPRIV:
 583
 584                 /*
 585                  * Allow jail to set various resource limits and login
 586                  * properties, and for now, exceed process resource limits.
 587                  */
 588         case PRIV_PROC_LIMIT:
 589         case PRIV_PROC_SETLOGIN:
 590         case PRIV_PROC_SETRLIMIT:
 591
 592                 /*
 593                  * System V and POSIX IPC privileges are granted in jail.
 594                  */
 595         case PRIV_IPC_READ:
 596         case PRIV_IPC_WRITE:
 597         case PRIV_IPC_EXEC:
 598         case PRIV_IPC_ADMIN:
 599         case PRIV_IPC_MSGSIZE:
 600         case PRIV_MQ_ADMIN:
 601
 602                 /*
 603                  * Jail implements its own inter-process limits, so allow
 604                  * root processes in jail to change scheduling on other
 605                  * processes in the same jail.  Likewise for signalling.
 606                  */
 607         case PRIV_SCHED_DIFFCRED:
 608         case PRIV_SIGNAL_DIFFCRED:
 609         case PRIV_SIGNAL_SUGID:
 610
 611                 /*
 612                  * Allow jailed processes to write to sysctls marked as jail
 613                  * writable.
 614                  */
 615         case PRIV_SYSCTL_WRITEJAIL:
 616
 617                 /*
 618                  * Allow root in jail to manage a variety of quota
 619                  * properties.  Some are a bit surprising and should be
 620                  * reconsidered.
 621                  */
 622         case PRIV_UFS_GETQUOTA:
 623         case PRIV_UFS_QUOTAOFF:         /* XXXRW: Slightly surprising. */
 624         case PRIV_UFS_QUOTAON:          /* XXXRW: Slightly surprising. */
 625         case PRIV_UFS_SETQUOTA:
 626         case PRIV_UFS_SETUSE:           /* XXXRW: Slightly surprising. */
 627
 628                 /*
 629                  * Since Jail relies on chroot() to implement file system
 630                  * protections, grant many VFS privileges to root in jail.
 631                  * Be careful to exclude mount-related and NFS-related
 632                  * privileges.
 633                  */
 634         case PRIV_VFS_READ:
 635         case PRIV_VFS_WRITE:
 636         case PRIV_VFS_ADMIN:
 637         case PRIV_VFS_EXEC:
 638         case PRIV_VFS_LOOKUP:
 639         case PRIV_VFS_BLOCKRESERVE:     /* XXXRW: Slightly surprising. */
 640         case PRIV_VFS_CHFLAGS_DEV:
 641         case PRIV_VFS_CHOWN:
 642         case PRIV_VFS_CHROOT:
 643         case PRIV_VFS_CLEARSUGID:
 644         case PRIV_VFS_FCHROOT:
 645         case PRIV_VFS_LINK:
 646         case PRIV_VFS_SETGID:
 647         case PRIV_VFS_STICKYFILE:
 648                 return (0);
 649
 650                 /*
 651                  * Depending on the global setting, allow privilege of
 652                  * setting system flags.
 653                  */
 654         case PRIV_VFS_SYSFLAGS:
 655                 if (jail_chflags_allowed)
 656                         return (0);
 657                 else
 658                         return (EPERM);
 659
 660                 /*
 661                  * Allow jailed root to bind reserved ports.
 662                  */
 663         case PRIV_NETINET_RESERVEDPORT:
 664                 return (0);
 665
 666                 /*
 667                  * Conditionally allow creating raw sockets in jail.
 668                  */
 669         case PRIV_NETINET_RAW:
 670                 if (jail_allow_raw_sockets)
 671                         return (0);
 672                 else
 673                         return (EPERM);
 674
 675                 /*
 676                  * Since jail implements its own visibility limits on netstat
 677                  * sysctls, allow getcred.  This allows identd to work in
 678                  * jail.
 679                  */
 680         case PRIV_NETINET_GETCRED:
 681                 return (0);
 682
 683         default:
 684                 /*
 685                  * In all remaining cases, deny the privilege request.  This
 686                  * includes almost all network privileges, many system
 687                  * configuration privileges.
 688                  */
 689                 return (EPERM);
 690         }
 691 }
 692
 693 static int
 694 sysctl_jail_list(SYSCTL_HANDLER_ARGS)
 695 {
 696         struct xprison *xp, *sxp;
 697         struct prison *pr;
 698         int count, error;
 699
 700         if (jailed(req->td->td_ucred))
 701                 return (0);
 702 retry:
 703         mtx_lock(&allprison_mtx);
 704         count = prisoncount;
 705         mtx_unlock(&allprison_mtx);
 706
 707         if (count == 0)
 708                 return (0);
 709
 710         sxp = xp = malloc(sizeof(*xp) * count, M_TEMP, M_WAITOK | M_ZERO);
 711         mtx_lock(&allprison_mtx);
 712         if (count != prisoncount) {
 713                 mtx_unlock(&allprison_mtx);
 714                 free(sxp, M_TEMP);
 715                 goto retry;
 716         }
 717
 718         LIST_FOREACH(pr, &allprison, pr_list) {
 719                 mtx_lock(&pr->pr_mtx);
 720                 xp->pr_version = XPRISON_VERSION;
 721                 xp->pr_id = pr->pr_id;
 722                 strlcpy(xp->pr_path, pr->pr_path, sizeof(xp->pr_path));
 723                 strlcpy(xp->pr_host, pr->pr_host, sizeof(xp->pr_host));
 724                 xp->pr_ip = pr->pr_ip;
 725                 mtx_unlock(&pr->pr_mtx);
 726                 xp++;
 727         }
 728         mtx_unlock(&allprison_mtx);
 729
 730         error = SYSCTL_OUT(req, sxp, sizeof(*sxp) * count);
 731         free(sxp, M_TEMP);
 732         if (error)
 733                 return (error);
 734         return (0);
 735 }
 736
 737 SYSCTL_OID(_security_jail, OID_AUTO, list, CTLTYPE_STRUCT | CTLFLAG_RD,
 738     NULL, 0, sysctl_jail_list, "S", "List of active jails");
 739
 740 static int
 741 sysctl_jail_jailed(SYSCTL_HANDLER_ARGS)
 742 {
 743         int error, injail;
 744
 745         injail = jailed(req->td->td_ucred);
 746         error = SYSCTL_OUT(req, &injail, sizeof(injail));
 747
 748         return (error);
 749 }
 750 SYSCTL_PROC(_security_jail, OID_AUTO, jailed, CTLTYPE_INT | CTLFLAG_RD,
 751     NULL, 0, sysctl_jail_jailed, "I", "Process in jail?");