Re: [PATCH v5] Smack: limited capability for changing process label
From: Casey Schaufler
Date: Mon Oct 19 2015 - 19:46:01 EST
On 10/19/2015 9:23 AM, Rafal Krypa wrote:
> From: Zbigniew Jasinski <z.jasinski@xxxxxxxxxxx>
>
> This feature introduces new kernel interface:
>
> - <smack_fs>/relabel-self - for setting transition labels list
>
> This list is used to control smack label transition mechanism.
> List is set by, and per process. Process can transit to new label only if
> label is on the list. Only process with CAP_MAC_ADMIN capability can add
> labels to this list. With this list, process can change it's label without
> CAP_MAC_ADMIN but only once. After label changing, list is unset.
>
> Changes in v2:
> * use list_for_each_entry instead of _rcu during label write
> * added missing description in security/Smack.txt
>
> Changes in v3:
> * squashed into one commit
>
> Changes in v4:
> * switch from global list to per-task list
> * since the per-task list is accessed only by the task itself
> there is no need to use synchronization mechanisms on it
>
> Changes in v5:
> * change smackfs interface of relabel-self to the one used for onlycap
> multiple labels are accepted, separated by space, which
> replace the previous list upon write
>
> Signed-off-by: Zbigniew Jasinski <z.jasinski@xxxxxxxxxxx>
> Signed-off-by: Rafal Krypa <r.krypa@xxxxxxxxxxx>
Acked-by: Casey Schaufler <casey@xxxxxxxxxxxxxxxx>
Applied-to: https://github.com/cschaufler/smack-next.git#smack-for-4.4
> ---
> Documentation/security/Smack.txt | 10 ++
> security/smack/smack.h | 4 +-
> security/smack/smack_access.c | 6 +-
> security/smack/smack_lsm.c | 57 ++++++++++-
> security/smack/smackfs.c | 202 ++++++++++++++++++++++++++++++++-------
> 5 files changed, 238 insertions(+), 41 deletions(-)
>
> diff --git a/Documentation/security/Smack.txt b/Documentation/security/Smack.txt
> index 5e6d07f..945cc63 100644
> --- a/Documentation/security/Smack.txt
> +++ b/Documentation/security/Smack.txt
> @@ -255,6 +255,16 @@ unconfined
> the access permitted if it wouldn't be otherwise. Note that this
> is dangerous and can ruin the proper labeling of your system.
> It should never be used in production.
> +relabel-self
> + This interface contains a list of labels to which the process can
> + transition to, by writing to /proc/self/attr/current.
> + Normally a process can change its own label to any legal value, but only
> + if it has CAP_MAC_ADMIN. This interface allows a process without
> + CAP_MAC_ADMIN to relabel itself to one of labels from predefined list.
> + A process without CAP_MAC_ADMIN can change its label only once. When it
> + does, this list will be cleared.
> + The values are set by writing the desired labels, separated
> + by spaces, to the file or cleared by writing "-" to the file.
>
> If you are using the smackload utility
> you can add access rules in /etc/smack/accesses. They take the form:
> diff --git a/security/smack/smack.h b/security/smack/smack.h
> index fff0c61..6c91156 100644
> --- a/security/smack/smack.h
> +++ b/security/smack/smack.h
> @@ -115,6 +115,7 @@ struct task_smack {
> struct smack_known *smk_forked; /* label when forked */
> struct list_head smk_rules; /* per task access rules */
> struct mutex smk_rules_lock; /* lock for the rules */
> + struct list_head smk_relabel; /* transit allowed labels */
> };
>
> #define SMK_INODE_INSTANT 0x01 /* inode is instantiated */
> @@ -169,7 +170,7 @@ struct smk_port_label {
> };
> #endif /* SMACK_IPV6_PORT_LABELING */
>
> -struct smack_onlycap {
> +struct smack_known_list_elem {
> struct list_head list;
> struct smack_known *smk_label;
> };
> @@ -301,6 +302,7 @@ struct smack_known *smk_import_entry(const char *, int);
> void smk_insert_entry(struct smack_known *skp);
> struct smack_known *smk_find_entry(const char *);
> int smack_privileged(int cap);
> +void smk_destroy_label_list(struct list_head *list);
>
> /*
> * Shared data.
> diff --git a/security/smack/smack_access.c b/security/smack/smack_access.c
> index bc1053f..a283f9e 100644
> --- a/security/smack/smack_access.c
> +++ b/security/smack/smack_access.c
> @@ -637,7 +637,7 @@ DEFINE_MUTEX(smack_onlycap_lock);
> int smack_privileged(int cap)
> {
> struct smack_known *skp = smk_of_current();
> - struct smack_onlycap *sop;
> + struct smack_known_list_elem *sklep;
>
> /*
> * All kernel tasks are privileged
> @@ -654,8 +654,8 @@ int smack_privileged(int cap)
> return 1;
> }
>
> - list_for_each_entry_rcu(sop, &smack_onlycap_list, list) {
> - if (sop->smk_label == skp) {
> + list_for_each_entry_rcu(sklep, &smack_onlycap_list, list) {
> + if (sklep->smk_label == skp) {
> rcu_read_unlock();
> return 1;
> }
> diff --git a/security/smack/smack_lsm.c b/security/smack/smack_lsm.c
> index 996c889..036d8b2 100644
> --- a/security/smack/smack_lsm.c
> +++ b/security/smack/smack_lsm.c
> @@ -326,6 +326,7 @@ static struct task_smack *new_task_smack(struct smack_known *task,
> tsp->smk_task = task;
> tsp->smk_forked = forked;
> INIT_LIST_HEAD(&tsp->smk_rules);
> + INIT_LIST_HEAD(&tsp->smk_relabel);
> mutex_init(&tsp->smk_rules_lock);
>
> return tsp;
> @@ -361,6 +362,35 @@ static int smk_copy_rules(struct list_head *nhead, struct list_head *ohead,
> }
>
> /**
> + * smk_copy_relabel - copy smk_relabel labels list
> + * @nhead: new rules header pointer
> + * @ohead: old rules header pointer
> + * @gfp: type of the memory for the allocation
> + *
> + * Returns 0 on success, -ENOMEM on error
> + */
> +static int smk_copy_relabel(struct list_head *nhead, struct list_head *ohead,
> + gfp_t gfp)
> +{
> + struct smack_known_list_elem *nklep;
> + struct smack_known_list_elem *oklep;
> +
> + INIT_LIST_HEAD(nhead);
> +
> + list_for_each_entry(oklep, ohead, list) {
> + nklep = kzalloc(sizeof(struct smack_known_list_elem), gfp);
> + if (nklep == NULL) {
> + smk_destroy_label_list(nhead);
> + return -ENOMEM;
> + }
> + nklep->smk_label = oklep->smk_label;
> + list_add(&nklep->list, nhead);
> + }
> +
> + return 0;
> +}
> +
> +/**
> * smk_ptrace_mode - helper function for converting PTRACE_MODE_* into MAY_*
> * @mode - input mode in form of PTRACE_MODE_*
> *
> @@ -1922,6 +1952,8 @@ static void smack_cred_free(struct cred *cred)
> return;
> cred->security = NULL;
>
> + smk_destroy_label_list(&tsp->smk_relabel);
> +
> list_for_each_safe(l, n, &tsp->smk_rules) {
> rp = list_entry(l, struct smack_rule, list);
> list_del(&rp->list);
> @@ -1953,6 +1985,10 @@ static int smack_cred_prepare(struct cred *new, const struct cred *old,
> if (rc != 0)
> return rc;
>
> + rc = smk_copy_relabel(&new_tsp->smk_relabel, &old_tsp->smk_relabel, gfp);
> + if (rc != 0)
> + return rc;
> +
> new->security = new_tsp;
> return 0;
> }
> @@ -3549,9 +3585,11 @@ static int smack_getprocattr(struct task_struct *p, char *name, char **value)
> static int smack_setprocattr(struct task_struct *p, char *name,
> void *value, size_t size)
> {
> - struct task_smack *tsp;
> + struct task_smack *tsp = current_security();
> struct cred *new;
> struct smack_known *skp;
> + struct smack_known_list_elem *sklep;
> + int rc;
>
> /*
> * Changing another process' Smack value is too dangerous
> @@ -3560,7 +3598,7 @@ static int smack_setprocattr(struct task_struct *p, char *name,
> if (p != current)
> return -EPERM;
>
> - if (!smack_privileged(CAP_MAC_ADMIN))
> + if (!smack_privileged(CAP_MAC_ADMIN) && list_empty(&tsp->smk_relabel))
> return -EPERM;
>
> if (value == NULL || size == 0 || size >= SMK_LONGLABEL)
> @@ -3579,12 +3617,27 @@ static int smack_setprocattr(struct task_struct *p, char *name,
> if (skp == &smack_known_web)
> return -EPERM;
>
> + if (!smack_privileged(CAP_MAC_ADMIN)) {
> + rc = -EPERM;
> + list_for_each_entry(sklep, &tsp->smk_relabel, list)
> + if (sklep->smk_label == skp) {
> + rc = 0;
> + break;
> + }
> + if (rc)
> + return rc;
> + }
> +
> new = prepare_creds();
> if (new == NULL)
> return -ENOMEM;
>
> tsp = new->security;
> tsp->smk_task = skp;
> + /*
> + * process can change its label only once
> + */
> + smk_destroy_label_list(&tsp->smk_relabel);
>
> commit_creds(new);
> return size;
> diff --git a/security/smack/smackfs.c b/security/smack/smackfs.c
> index c20b154..35366ba 100644
> --- a/security/smack/smackfs.c
> +++ b/security/smack/smackfs.c
> @@ -61,6 +61,7 @@ enum smk_inos {
> #if IS_ENABLED(CONFIG_IPV6)
> SMK_NET6ADDR = 23, /* single label IPv6 hosts */
> #endif /* CONFIG_IPV6 */
> + SMK_RELABEL_SELF = 24, /* relabel possible without CAP_MAC_ADMIN */
> };
>
> /*
> @@ -1914,10 +1915,10 @@ static void *onlycap_seq_next(struct seq_file *s, void *v, loff_t *pos)
> static int onlycap_seq_show(struct seq_file *s, void *v)
> {
> struct list_head *list = v;
> - struct smack_onlycap *sop =
> - list_entry_rcu(list, struct smack_onlycap, list);
> + struct smack_known_list_elem *sklep =
> + list_entry_rcu(list, struct smack_known_list_elem, list);
>
> - seq_puts(s, sop->smk_label->smk_known);
> + seq_puts(s, sklep->smk_label->smk_known);
> seq_putc(s, ' ');
>
> return 0;
> @@ -1974,6 +1975,54 @@ static void smk_list_swap_rcu(struct list_head *public,
> }
>
> /**
> + * smk_parse_label_list - parse list of Smack labels, separated by spaces
> + *
> + * @data: the string to parse
> + * @private: destination list
> + *
> + * Returns zero on success or error code, as appropriate
> + */
> +static int smk_parse_label_list(char *data, struct list_head *list)
> +{
> + char *tok;
> + struct smack_known *skp;
> + struct smack_known_list_elem *sklep;
> +
> + while ((tok = strsep(&data, " ")) != NULL) {
> + if (!*tok)
> + continue;
> +
> + skp = smk_import_entry(tok, 0);
> + if (IS_ERR(skp))
> + return PTR_ERR(skp);
> +
> + sklep = kzalloc(sizeof(*sklep), GFP_KERNEL);
> + if (sklep == NULL)
> + return -ENOMEM;
> +
> + sklep->smk_label = skp;
> + list_add(&sklep->list, list);
> + }
> +
> + return 0;
> +}
> +
> +/**
> + * smk_destroy_label_list - destroy a list of smack_known_list_elem
> + * @head: header pointer of the list to destroy
> + */
> +void smk_destroy_label_list(struct list_head *list)
> +{
> + struct smack_known_list_elem *sklep;
> + struct smack_known_list_elem *sklep2;
> +
> + list_for_each_entry_safe(sklep, sklep2, list, list)
> + kfree(sklep);
> +
> + INIT_LIST_HEAD(list);
> +}
> +
> +/**
> * smk_write_onlycap - write() for smackfs/onlycap
> * @file: file pointer, not actually used
> * @buf: where to get the data from
> @@ -1986,13 +2035,8 @@ static ssize_t smk_write_onlycap(struct file *file, const char __user *buf,
> size_t count, loff_t *ppos)
> {
> char *data;
> - char *data_parse;
> - char *tok;
> - struct smack_known *skp;
> - struct smack_onlycap *sop;
> - struct smack_onlycap *sop2;
> LIST_HEAD(list_tmp);
> - int rc = count;
> + int rc;
>
> if (!smack_privileged(CAP_MAC_ADMIN))
> return -EPERM;
> @@ -2006,26 +2050,7 @@ static ssize_t smk_write_onlycap(struct file *file, const char __user *buf,
> return -EFAULT;
> }
>
> - data_parse = data;
> - while ((tok = strsep(&data_parse, " ")) != NULL) {
> - if (!*tok)
> - continue;
> -
> - skp = smk_import_entry(tok, 0);
> - if (IS_ERR(skp)) {
> - rc = PTR_ERR(skp);
> - break;
> - }
> -
> - sop = kzalloc(sizeof(*sop), GFP_KERNEL);
> - if (sop == NULL) {
> - rc = -ENOMEM;
> - break;
> - }
> -
> - sop->smk_label = skp;
> - list_add_rcu(&sop->list, &list_tmp);
> - }
> + rc = smk_parse_label_list(data, &list_tmp);
> kfree(data);
>
> /*
> @@ -2038,17 +2063,14 @@ static ssize_t smk_write_onlycap(struct file *file, const char __user *buf,
> * But do so only on invalid label, not on system errors.
> * The invalid label must be first to count as clearing attempt.
> */
> - if (rc == -EINVAL && list_empty(&list_tmp))
> - rc = count;
> -
> - if (rc >= 0) {
> + if (!rc || (rc == -EINVAL && list_empty(&list_tmp))) {
> mutex_lock(&smack_onlycap_lock);
> smk_list_swap_rcu(&smack_onlycap_list, &list_tmp);
> mutex_unlock(&smack_onlycap_lock);
> + rc = count;
> }
>
> - list_for_each_entry_safe(sop, sop2, &list_tmp, list)
> - kfree(sop);
> + smk_destroy_label_list(&list_tmp);
>
> return rc;
> }
> @@ -2698,6 +2720,113 @@ static const struct file_operations smk_syslog_ops = {
> .llseek = default_llseek,
> };
>
> +/*
> + * Seq_file read operations for /smack/relabel-self
> + */
> +
> +static void *relabel_self_seq_start(struct seq_file *s, loff_t *pos)
> +{
> + struct task_smack *tsp = current_security();
> +
> + return smk_seq_start(s, pos, &tsp->smk_relabel);
> +}
> +
> +static void *relabel_self_seq_next(struct seq_file *s, void *v, loff_t *pos)
> +{
> + struct task_smack *tsp = current_security();
> +
> + return smk_seq_next(s, v, pos, &tsp->smk_relabel);
> +}
> +
> +static int relabel_self_seq_show(struct seq_file *s, void *v)
> +{
> + struct list_head *list = v;
> + struct smack_known_list_elem *sklep =
> + list_entry(list, struct smack_known_list_elem, list);
> +
> + seq_puts(s, sklep->smk_label->smk_known);
> + seq_putc(s, ' ');
> +
> + return 0;
> +}
> +
> +static const struct seq_operations relabel_self_seq_ops = {
> + .start = relabel_self_seq_start,
> + .next = relabel_self_seq_next,
> + .show = relabel_self_seq_show,
> + .stop = smk_seq_stop,
> +};
> +
> +/**
> + * smk_open_relabel_self - open() for /smack/relabel-self
> + * @inode: inode structure representing file
> + * @file: "relabel-self" file pointer
> + *
> + * Connect our relabel_self_seq_* operations with /smack/relabel-self
> + * file_operations
> + */
> +static int smk_open_relabel_self(struct inode *inode, struct file *file)
> +{
> + return seq_open(file, &relabel_self_seq_ops);
> +}
> +
> +/**
> + * smk_write_relabel_self - write() for /smack/relabel-self
> + * @file: file pointer, not actually used
> + * @buf: where to get the data from
> + * @count: bytes sent
> + * @ppos: where to start - must be 0
> + *
> + */
> +static ssize_t smk_write_relabel_self(struct file *file, const char __user *buf,
> + size_t count, loff_t *ppos)
> +{
> + struct task_smack *tsp = current_security();
> + char *data;
> + int rc;
> + LIST_HEAD(list_tmp);
> +
> + /*
> + * Must have privilege.
> + */
> + if (!smack_privileged(CAP_MAC_ADMIN))
> + return -EPERM;
> +
> + /*
> + * Enough data must be present.
> + */
> + if (*ppos != 0)
> + return -EINVAL;
> +
> + data = kzalloc(count + 1, GFP_KERNEL);
> + if (data == NULL)
> + return -ENOMEM;
> +
> + if (copy_from_user(data, buf, count) != 0) {
> + kfree(data);
> + return -EFAULT;
> + }
> +
> + rc = smk_parse_label_list(data, &list_tmp);
> + kfree(data);
> +
> + if (!rc || (rc == -EINVAL && list_empty(&list_tmp))) {
> + smk_destroy_label_list(&tsp->smk_relabel);
> + list_splice(&list_tmp, &tsp->smk_relabel);
> + return count;
> + }
> +
> + smk_destroy_label_list(&list_tmp);
> + return rc;
> +}
> +
> +static const struct file_operations smk_relabel_self_ops = {
> + .open = smk_open_relabel_self,
> + .read = seq_read,
> + .llseek = seq_lseek,
> + .write = smk_write_relabel_self,
> + .release = seq_release,
> +};
>
> /**
> * smk_read_ptrace - read() for /smack/ptrace
> @@ -2824,6 +2953,9 @@ static int smk_fill_super(struct super_block *sb, void *data, int silent)
> [SMK_NET6ADDR] = {
> "ipv6host", &smk_net6addr_ops, S_IRUGO|S_IWUSR},
> #endif /* CONFIG_IPV6 */
> + [SMK_RELABEL_SELF] = {
> + "relabel-self", &smk_relabel_self_ops,
> + S_IRUGO|S_IWUGO},
> /* last one */
> {""}
> };
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/