/* * Capability checking for all system calls * * Copyright (C) 2009 Bahadir Balban */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include INC_GLUE(message.h) #include INC_GLUE(ipc.h) void capability_init(struct capability *cap) { cap->capid = id_new(&kernel_resources.capability_ids); link_init(&cap->list); } /* * Boot-time function to create capability without * capability checking */ struct capability *boot_capability_create(void) { struct capability *cap = boot_alloc_capability(); capability_init(cap); return cap; } struct capability *capability_create(void) { struct capability *cap; if (!(cap = alloc_capability())) return 0; capability_init(cap); return cap; } #if defined(CONFIG_CAPABILITIES) int capability_consume(struct capability *cap, int quantity) { if (cap->size < cap->used + quantity) return -ENOCAP; cap->used += quantity; return 0; } int capability_free(struct capability *cap, int quantity) { BUG_ON((cap->used -= quantity) < 0); return 0; } #else int capability_consume(struct capability *cap, int quantity) { return 0; } int capability_free(struct capability *cap, int quantity) { return 0; } #endif struct capability *cap_list_find_by_rtype(struct cap_list *cap_list, unsigned int rtype) { struct capability *cap; list_foreach_struct(cap, &cap_list->caps, list) if (cap_rtype(cap) == rtype) return cap; return 0; } /* * Find a capability from a list by its resource type * Search all capability lists that task is allowed. * * FIXME: * Tasks should not always search for a capability randomly. Consider * mutexes, if a mutex is freed, it needs to be accounted to private * pool first if that is not full, because freeing it into shared * pool may lose the mutex right to another task. In other words, * when you're freeing a mutex, we should know which capability pool * to free it to. * * In conclusion freeing of pool-type capabilities need to be done * in order of privacy. */ struct capability *capability_find_by_rtype(struct ktcb *task, unsigned int rtype) { struct capability *cap; /* Search task's own list */ list_foreach_struct(cap, &task->cap_list.caps, list) if (cap_rtype(cap) == rtype) return cap; /* Search space list */ list_foreach_struct(cap, &task->space->cap_list.caps, list) if (cap_rtype(cap) == rtype) return cap; /* Search container list */ list_foreach_struct(cap, &task->container->cap_list.caps, list) if (cap_rtype(cap) == rtype) return cap; return 0; } struct capability *cap_find_by_capid(l4id_t capid, struct cap_list **cap_list) { struct capability *cap; struct ktcb *task = current; /* Search task's own list */ list_foreach_struct(cap, &task->cap_list.caps, list) if (cap->capid == capid) { *cap_list = &task->cap_list; return cap; } /* Search space list */ list_foreach_struct(cap, &task->space->cap_list.caps, list) if (cap->capid == capid) { *cap_list = &task->space->cap_list; return cap; } /* Search container list */ list_foreach_struct(cap, &task->container->cap_list.caps, list) if (cap->capid == capid) { *cap_list = &task->container->cap_list; return cap; } return 0; } int cap_count(struct ktcb *task) { return task->cap_list.ncaps + task->space->cap_list.ncaps + task->container->cap_list.ncaps; } typedef struct capability *(*cap_match_func_t) \ (struct capability *cap, void *match_args); /* * This is used by every system call to match each * operation with a capability in a syscall-specific way. */ struct capability *cap_find(struct ktcb *task, cap_match_func_t cap_match_func, void *match_args, unsigned int cap_type) { struct capability *cap, *found; /* Search task's own list */ list_foreach_struct(cap, &task->cap_list.caps, list) if (cap_type(cap) == cap_type && ((found = cap_match_func(cap, match_args)))) return found; /* Search space list */ list_foreach_struct(cap, &task->space->cap_list.caps, list) if (cap_type(cap) == cap_type && ((found = cap_match_func(cap, match_args)))) return found; /* Search container list */ list_foreach_struct(cap, &task->container->cap_list.caps, list) if (cap_type(cap) == cap_type && ((found = cap_match_func(cap, match_args)))) return found; return 0; } struct sys_mutex_args { unsigned long address; unsigned int op; }; /* * Check broadly the ability to do mutex ops. Check it by * the thread, space or container, (i.e. the group that can * do this operation broadly) * * Note, that we check mutex_address elsewhere as a quick, * per-task virt_to_phys translation that would not get * easily/quickly satisfied by a memory capability checking. * * While this is not %100 right from a capability checking * point-of-view, it is a shortcut that works and makes sense. * * For sake of completion, the right way to do it would be to * add MUTEX_LOCKABLE, MUTEX_UNLOCKABLE attributes to both * virtual and physical memory caps of a task, search those * to validate the address. But we would have to translate * from the page tables either ways. */ struct capability * cap_match_mutex(struct capability *cap, void *args) { /* Unconditionally expect these flags */ unsigned int perms = CAP_UMUTEX_LOCK | CAP_UMUTEX_UNLOCK; if ((cap->access & perms) != perms) return 0; /* Now check the usual restype/resid pair */ switch (cap_rtype(cap)) { case CAP_RTYPE_THREAD: if (current->tid != cap->resid) return 0; break; case CAP_RTYPE_SPACE: if (current->space->spid != cap->resid) return 0; break; case CAP_RTYPE_CONTAINER: if (current->container->cid != cap->resid) return 0; break; default: BUG(); /* Unknown cap type is a bug */ } return cap; } struct sys_capctrl_args { unsigned int req; unsigned int flags; struct ktcb *task; }; struct capability * cap_match_capctrl(struct capability *cap, void *args_ptr) { struct sys_capctrl_args *args = args_ptr; unsigned int req = args->req; struct ktcb *target = args->task; /* Check operation privileges */ switch (req) { case CAP_CONTROL_NCAPS: case CAP_CONTROL_READ: if (!(cap->access & CAP_CAP_READ)) return 0; break; case CAP_CONTROL_SHARE: if (!(cap->access & CAP_CAP_SHARE)) return 0; break; case CAP_CONTROL_GRANT: if (!(cap->access & CAP_CAP_GRANT)) return 0; break; case CAP_CONTROL_REPLICATE: if (!(cap->access & CAP_CAP_REPLICATE)) return 0; break; case CAP_CONTROL_SPLIT: if (!(cap->access & CAP_CAP_SPLIT)) return 0; break; case CAP_CONTROL_DEDUCE: if (!(cap->access & CAP_CAP_DEDUCE)) return 0; break; case CAP_CONTROL_DESTROY: if (!(cap->access & CAP_CAP_DESTROY)) return 0; break; default: /* We refuse to accept anything else */ return 0; } /* Now check the usual restype/resid pair */ switch (cap_rtype(cap)) { case CAP_RTYPE_THREAD: if (target->tid != cap->resid) return 0; break; case CAP_RTYPE_SPACE: if (target->space->spid != cap->resid) return 0; break; case CAP_RTYPE_CONTAINER: if (target->container->cid != cap->resid) return 0; break; default: BUG(); /* Unknown cap type is a bug */ } return cap; } struct sys_ipc_args { struct ktcb *task; unsigned int ipc_type; unsigned int xfer_type; }; /* * Matches ipc direction, transfer type and target resource. * * Currently, receives are not checked as only sends have * a solid target id. Receives can be from any thread with * no particular target. */ struct capability * cap_match_ipc(struct capability *cap, void *args_ptr) { struct sys_ipc_args *args = args_ptr; struct ktcb *target = args->task; /* Check ipc type privileges */ switch (args->xfer_type) { case IPC_FLAGS_SHORT: if (!(cap->access & CAP_IPC_SHORT)) return 0; break; case IPC_FLAGS_FULL: if (!(cap->access & CAP_IPC_FULL)) return 0; break; case IPC_FLAGS_EXTENDED: if (!(cap->access & CAP_IPC_EXTENDED)) return 0; break; default: return 0; } /* NOTE: We only check on send capability */ if (args->ipc_type & IPC_SEND) if (!(cap->access & CAP_IPC_SEND)) return 0; /* * We have a target thread, check if capability match * any resource fields in target */ switch (cap_rtype(cap)) { case CAP_RTYPE_THREAD: if (target->tid != cap->resid) return 0; break; case CAP_RTYPE_SPACE: if (target->space->spid != cap->resid) return 0; break; case CAP_RTYPE_CONTAINER: if (target->container->cid != cap->resid) return 0; break; default: BUG(); /* Unknown cap type is a bug */ } return cap; } struct sys_exregs_args { struct exregs_data *exregs; struct ktcb *task; }; /* * CAP_TYPE_EXREGS already matched upon entry */ struct capability * cap_match_exregs(struct capability *cap, void *args_ptr) { struct sys_exregs_args *args = args_ptr; struct exregs_data *exregs = args->exregs; struct ktcb *target = args->task; /* Check operation privileges */ if (exregs->valid_vect & EXREGS_VALID_REGULAR_REGS) if (!(cap->access & CAP_EXREGS_RW_REGS)) return 0; if (exregs->valid_vect & EXREGS_VALID_SP) if (!(cap->access & CAP_EXREGS_RW_SP)) return 0; if (exregs->valid_vect & EXREGS_VALID_PC) if (!(cap->access & CAP_EXREGS_RW_PC)) return 0; if (args->exregs->valid_vect & EXREGS_SET_UTCB) if (!(cap->access & CAP_EXREGS_RW_UTCB)) return 0; if (args->exregs->valid_vect & EXREGS_SET_PAGER) if (!(cap->access & CAP_EXREGS_RW_PAGER)) return 0; /* * We have a target thread, check if capability * match any resource fields in target. */ switch (cap_rtype(cap)) { case CAP_RTYPE_THREAD: if (target->tid != cap->resid) return 0; break; case CAP_RTYPE_SPACE: if (target->space->spid != cap->resid) return 0; break; case CAP_RTYPE_CONTAINER: if (target->container->cid != cap->resid) return 0; break; default: BUG(); /* Unknown cap type is a bug */ } return cap; } /* * FIXME: Issues on capabilities: * * As new pagers, thread groups, * thread ids, spaces are created, we need to * give them thread_control capabilities dynamically, * based on those ids!!! How do we get to do that, so that * in userspace it looks not so difficult ??? * * What do you match here? * * THREAD_CREATE: * - TC_SAME_SPACE * - spid -> Does thread have cap to create in that space? * - cid -> Does thread have cap to create in that container? * - tgid -> Does thread have cap to create in that thread group? * - pagerid -> Does thread have cap to create in that group of paged threads? * - TC_NEW_SPACE or TC_COPY_SPACE * - Check cid, tgid, pagerid, * - TC_SHARE_GROUP * - Check tgid * - TC_AS_PAGER * - pagerid -> Does thread have cap to create in that group of paged threads? * - TC_SHARE_PAGER * - pagerid -> Does thread have cap to create in that group of paged threads? * New group -> New set of caps, thread_control, exregs, ipc, ... all of them! * New pager -> New set of caps for that pager. * New thread -> New set of caps for that thread! * New space -> New set of caps for that space! So many capabilities! */ struct sys_tctrl_args { struct ktcb *task; unsigned int flags; struct task_ids *ids; }; /* * CAP_TYPE_TCTRL matched upon entry */ struct capability *cap_match_thread(struct capability *cap, void *args_ptr) { struct sys_tctrl_args *args = args_ptr; struct ktcb *target = args->task; unsigned int action_flags = args->flags & THREAD_ACTION_MASK; /* Check operation privileges */ switch (action_flags) { case THREAD_CREATE: if (!(cap->access & CAP_TCTRL_CREATE)) return 0; break; case THREAD_DESTROY: if (!(cap->access & CAP_TCTRL_DESTROY)) return 0; break; case THREAD_SUSPEND: if (!(cap->access & CAP_TCTRL_SUSPEND)) return 0; break; case THREAD_RUN: if (!(cap->access & CAP_TCTRL_RUN)) return 0; break; case THREAD_RECYCLE: if (!(cap->access & CAP_TCTRL_RECYCLE)) return 0; break; case THREAD_WAIT: if (!(cap->access & CAP_TCTRL_WAIT)) return 0; break; default: /* We refuse to accept anything else */ return 0; } /* If no target and create, or vice versa, it really is a bug */ BUG_ON(!target && action_flags != THREAD_CREATE); BUG_ON(target && action_flags == THREAD_CREATE); if (action_flags == THREAD_CREATE) { /* * NOTE: Currently we only allow creation in * current container. * * TODO: Add capability checking for space, * as well. * * We _assume_ target is the largest group, * e.g. same container as current. We check * for `container' as target in capability */ if (cap_rtype(cap) != CAP_RTYPE_CONTAINER) return 0; if (cap->resid != curcont->cid) return 0; /* Resource type and id match, success */ return cap; } /* * We have a target thread, check if capability match * any resource fields in target */ switch (cap_rtype(cap)) { case CAP_RTYPE_THREAD: if (target->tid != cap->resid) return 0; break; case CAP_RTYPE_SPACE: if (target->space->spid != cap->resid) return 0; break; case CAP_RTYPE_CONTAINER: if (target->container->cid != cap->resid) return 0; break; default: BUG(); /* Unknown cap type is a bug */ } return cap; } struct sys_map_args { struct ktcb *task; unsigned long phys; unsigned long virt; unsigned long npages; unsigned int flags; }; /* * CAP_TYPE_MAP already matched upon entry */ struct capability *cap_match_mem(struct capability *cap, void *args_ptr) { struct sys_map_args *args = args_ptr; struct ktcb *target = args->task; unsigned long pfn; unsigned int perms; /* Set base according to what type of mem type we're matching */ if (cap_type(cap) == CAP_TYPE_MAP_PHYSMEM) pfn = __pfn(args->phys); else pfn = __pfn(args->virt); /* Check range */ if (cap->start > pfn || cap->end < pfn + args->npages) return 0; /* Check permissions */ switch (args->flags) { case MAP_USR_RW_FLAGS: perms = CAP_MAP_READ | CAP_MAP_WRITE | CAP_MAP_CACHED; if ((cap->access & perms) != perms) return 0; break; case MAP_USR_RO_FLAGS: perms = CAP_MAP_READ | CAP_MAP_CACHED; if ((cap->access & perms) != perms) return 0; break; case MAP_USR_IO_FLAGS: perms = CAP_MAP_READ | CAP_MAP_WRITE | CAP_MAP_UNCACHED; if ((cap->access & perms) != perms) return 0; break; default: /* Anything else is an invalid/unrecognised argument */ return 0; } /* * We have a target thread, check if capability match * any resource fields in target */ switch (cap_rtype(cap)) { case CAP_RTYPE_THREAD: if (target->tid != cap->resid) return 0; break; case CAP_RTYPE_SPACE: if (target->space->spid != cap->resid) return 0; break; case CAP_RTYPE_CONTAINER: if (target->container->cid != cap->resid) return 0; break; default: BUG(); /* Unknown cap type is a bug */ } return cap; } struct sys_irqctrl_args { struct ktcb *registrant; unsigned int req; unsigned int flags; l4id_t irq; }; /* * CAP_TYPE_MAP already matched upon entry. * * Match only device-specific details, e.g. irq registration * capability */ struct capability *cap_match_devmem(struct capability *cap, void *args_ptr) { struct sys_irqctrl_args *args = args_ptr; struct ktcb *target = args->registrant; unsigned int perms; /* It must be a physmem type */ if (cap_type(cap) != CAP_TYPE_MAP_PHYSMEM) return 0; /* It must be a device */ if (!cap_is_devmem(cap)) return 0; /* Irq numbers should match */ if (cap->irq != args->irq) return 0; /* Check permissions, we only check irq specific */ switch (args->req) { case IRQ_CONTROL_REGISTER: perms = CAP_IRQCTRL_REGISTER; if ((cap->access & perms) != perms) return 0; break; default: /* Anything else is an invalid/unrecognised argument */ return 0; } /* * Check that irq registration to target is covered * by the capability containment rules. */ switch (cap_rtype(cap)) { case CAP_RTYPE_THREAD: if (target->tid != cap->resid) return 0; break; case CAP_RTYPE_SPACE: if (target->space->spid != cap->resid) return 0; break; case CAP_RTYPE_CONTAINER: if (target->container->cid != cap->resid) return 0; break; default: BUG(); /* Unknown cap type is a bug */ } return cap; } /* * CAP_TYPE_IRQCTRL already matched */ struct capability *cap_match_irqctrl(struct capability *cap, void *args_ptr) { struct sys_irqctrl_args *args = args_ptr; struct ktcb *target = args->registrant; /* Check operation privileges */ switch (args->req) { case IRQ_CONTROL_REGISTER: if (!(cap->access & CAP_IRQCTRL_REGISTER)) return 0; break; default: /* We refuse to accept anything else */ return 0; } /* * Target thread is the thread that is going to * handle the irqs. Check if capability matches * the target in any of its containment level. */ switch (cap_rtype(cap)) { case CAP_RTYPE_THREAD: if (target->tid != cap->resid) return 0; break; case CAP_RTYPE_SPACE: if (target->space->spid != cap->resid) return 0; break; case CAP_RTYPE_CONTAINER: if (target->container->cid != cap->resid) return 0; break; default: BUG(); /* Unknown cap type is a bug */ } return cap; } #if defined(CONFIG_CAPABILITIES) int cap_mutex_check(unsigned long mutex_address, int mutex_op) { struct sys_mutex_args args = { .address = mutex_address, .op = mutex_op, }; if (!(cap_find(current, cap_match_mutex, &args, CAP_TYPE_UMUTEX))) return -ENOCAP; return 0; } int cap_cap_check(struct ktcb *task, unsigned int req, unsigned int flags) { struct sys_capctrl_args args = { .req = req, .flags = flags, .task = task, }; if (!(cap_find(current, cap_match_capctrl, &args, CAP_TYPE_CAP))) return -ENOCAP; return 0; } int cap_map_check(struct ktcb *target, unsigned long phys, unsigned long virt, unsigned long npages, unsigned int flags) { struct capability *physmem, *virtmem; struct sys_map_args args = { .task = target, .phys = phys, .virt = virt, .npages = npages, .flags = flags, }; if (!(physmem = cap_find(current, cap_match_mem, &args, CAP_TYPE_MAP_PHYSMEM))) return -ENOCAP; if (!(virtmem = cap_find(current, cap_match_mem, &args, CAP_TYPE_MAP_VIRTMEM))) return -ENOCAP; return 0; } /* * Limitation: We currently only check from sender's * perspective. This is because sender always targets a * real thread. Does sender have the right to do this ipc? */ int cap_ipc_check(l4id_t to, l4id_t from, unsigned int flags, unsigned int ipc_type) { struct ktcb *target; struct sys_ipc_args args; /* TODO: We don't check receivers, this works well for now. */ if (ipc_type != IPC_SEND && ipc_type != IPC_SENDRECV) return 0; /* * We're the sender, meaning we have * a real target */ if (!(target = tcb_find(to))) return -ESRCH; /* Set up other args */ args.xfer_type = ipc_flags_get_type(flags); args.ipc_type = ipc_type; args.task = target; if (!(cap_find(current, cap_match_ipc, &args, CAP_TYPE_IPC))) return -ENOCAP; return 0; } int cap_exregs_check(struct ktcb *task, struct exregs_data *exregs) { struct sys_exregs_args args = { .exregs = exregs, .task = task, }; /* We always search for current's caps */ if (!(cap_find(current, cap_match_exregs, &args, CAP_TYPE_EXREGS))) return -ENOCAP; return 0; } int cap_thread_check(struct ktcb *task, unsigned int flags, struct task_ids *ids) { struct sys_tctrl_args args = { .task = task, .flags = flags, .ids = ids, }; if (!(cap_find(current, cap_match_thread, &args, CAP_TYPE_TCTRL))) return -ENOCAP; return 0; } int cap_irq_check(struct ktcb *registrant, unsigned int req, unsigned int flags, l4id_t irq, struct capability **device_cap) { struct sys_irqctrl_args args = { .registrant = registrant, .req = req, .flags = flags, .irq = irq, }; /* Find the irq control capability of caller */ if (!(cap_find(current, cap_match_irqctrl, &args, CAP_TYPE_IRQCTRL))) return -ENOCAP; /* * Find the device capability and * check that it allows irq registration */ if (!(*device_cap = cap_find(current, cap_match_devmem, &args, CAP_TYPE_MAP_PHYSMEM))) return -ENOCAP; return 0; } #else /* Meaning !CONFIG_CAPABILITIES */ int cap_mutex_check(unsigned long mutex_address, int mutex_op) { return 0; } int cap_cap_check(struct ktcb *task, unsigned int req, unsigned int flags) { return 0; } int cap_ipc_check(l4id_t to, l4id_t from, unsigned int flags, unsigned int ipc_type) { return 0; } int cap_map_check(struct ktcb *task, unsigned long phys, unsigned long virt, unsigned long npages, unsigned int flags) { return 0; } int cap_exregs_check(struct ktcb *task, struct exregs_data *exregs) { return 0; } int cap_thread_check(struct ktcb *task, unsigned int flags, struct task_ids *ids) { return 0; } int cap_irq_check(struct ktcb *registrant, unsigned int req, unsigned int flags, l4id_t irq, struct capability **cap) { return 0; } #endif /* End of !CONFIG_CAPABILITIES */