Smack: allow for significantly longer Smack labels v4

V4 updated to current linux-security#next
Targeted for git://gitorious.org/smack-next/kernel.git

Modern application runtime environments like to use
naming schemes that are structured and generated without
human intervention. Even though the Smack limit of 23
characters for a label name is perfectly rational for
human use there have been complaints that the limit is
a problem in environments where names are composed from
a set or sources, including vendor, author, distribution
channel and application name. Names like

	softwarehouse-pgwodehouse-coolappstore-mellowmuskrats

are becoming harder to avoid. This patch introduces long
label support in Smack. Labels are now limited to 255
characters instead of the old 23.

The primary reason for limiting the labels to 23 characters
was so they could be directly contained in CIPSO category sets.
This is still done were possible, but for labels that are too
large a mapping is required. This is perfectly safe for communication
that stays "on the box" and doesn't require much coordination
between boxes beyond what would have been required to keep label
names consistent.

The bulk of this patch is in smackfs, adding and updating
administrative interfaces. Because existing APIs can't be
changed new ones that do much the same things as old ones
have been introduced.

The Smack specific CIPSO data representation has been removed
and replaced with the data format used by netlabel. The CIPSO
header is now computed when a label is imported rather than
on use. This results in improved IP performance. The smack
label is now allocated separately from the containing structure,
allowing for larger strings.

Four new /smack interfaces have been introduced as four
of the old interfaces strictly required labels be specified
in fixed length arrays.

The access interface is supplemented with the check interface:
	access  "Subject                 Object                  rwxat"
	access2 "Subject Object rwaxt"

The load interface is supplemented with the rules interface:
	load   "Subject                 Object                  rwxat"
	load2  "Subject Object rwaxt"

The load-self interface is supplemented with the self-rules interface:
	load-self   "Subject                 Object                  rwxat"
	load-self2  "Subject Object rwaxt"

The cipso interface is supplemented with the wire interface:
	cipso  "Subject                  lvl cnt  c1  c2 ..."
	cipso2 "Subject lvl cnt  c1  c2 ..."

The old interfaces are maintained for compatibility.

Signed-off-by: Casey Schaufler <casey@schaufler-ca.com>

1 files changed, 44 insertions, 141 deletions

diff --git a/security/smack/smack_lsm.c b/security/smack/smack_lsm.c
index 5f80075d7713..952b1f41fc78 100644
--- a/security/smack/smack_lsm.c
+++ b/security/smack/smack_lsm.c
@@ -30,7 +30,6 @@
 #include <linux/slab.h>
 #include <linux/mutex.h>
 #include <linux/pipe_fs_i.h>
-#include <net/netlabel.h>
 #include <net/cipso_ipv4.h>
 #include <linux/audit.h>
 #include <linux/magic.h>
@@ -57,16 +56,23 @@
 static char *smk_fetch(const char *name, struct inode *ip, struct dentry *dp)
 {
         int rc;
-        char in[SMK_LABELLEN];
+        char *buffer;
+        char *result = NULL;
 
         if (ip->i_op->getxattr == NULL)
                 return NULL;
 
-        rc = ip->i_op->getxattr(dp, name, in, SMK_LABELLEN);
-        if (rc < 0)
+        buffer = kzalloc(SMK_LONGLABEL, GFP_KERNEL);
+        if (buffer == NULL)
                 return NULL;
 
-        return smk_import(in, rc);
+        rc = ip->i_op->getxattr(dp, name, buffer, SMK_LONGLABEL);
+        if (rc > 0)
+                result = smk_import(buffer, rc);
+
+        kfree(buffer);
+
+        return result;
 }
 
 /**
@@ -825,7 +831,7 @@ static int smack_inode_setxattr(struct dentry *dentry, const char *name,
                  * check label validity here so import wont fail on
                  * post_setxattr
                  */
-                if (size == 0 || size >= SMK_LABELLEN ||
+                if (size == 0 || size >= SMK_LONGLABEL ||
                     smk_import(value, size) == NULL)
                         rc = -EINVAL;
         } else if (strcmp(name, XATTR_NAME_SMACKTRANSMUTE) == 0) {
@@ -1824,65 +1830,6 @@ static char *smack_host_label(struct sockaddr_in *sip)
 }
 
 /**
- * smack_set_catset - convert a capset to netlabel mls categories
- * @catset: the Smack categories
- * @sap: where to put the netlabel categories
- *
- * Allocates and fills attr.mls.cat
- */
-static void smack_set_catset(char *catset, struct netlbl_lsm_secattr *sap)
-{
-        unsigned char *cp;
-        unsigned char m;
-        int cat;
-        int rc;
-        int byte;
-
-        if (!catset)
-                return;
-
-        sap->flags |= NETLBL_SECATTR_MLS_CAT;
-        sap->attr.mls.cat = netlbl_secattr_catmap_alloc(GFP_ATOMIC);
-        sap->attr.mls.cat->startbit = 0;
-
-        for (cat = 1, cp = catset, byte = 0; byte < SMK_LABELLEN; cp++, byte++)
-                for (m = 0x80; m != 0; m >>= 1, cat++) {
-                        if ((m & *cp) == 0)
-                                continue;
-                        rc = netlbl_secattr_catmap_setbit(sap->attr.mls.cat,
-                                                          cat, GFP_ATOMIC);
-                }
-}
-
-/**
- * smack_to_secattr - fill a secattr from a smack value
- * @smack: the smack value
- * @nlsp: where the result goes
- *
- * Casey says that CIPSO is good enough for now.
- * It can be used to effect.
- * It can also be abused to effect when necessary.
- * Apologies to the TSIG group in general and GW in particular.
- */
-static void smack_to_secattr(char *smack, struct netlbl_lsm_secattr *nlsp)
-{
-        struct smack_cipso cipso;
-        int rc;
-
-        nlsp->domain = smack;
-        nlsp->flags = NETLBL_SECATTR_DOMAIN | NETLBL_SECATTR_MLS_LVL;
-
-        rc = smack_to_cipso(smack, &cipso);
-        if (rc == 0) {
-                nlsp->attr.mls.lvl = cipso.smk_level;
-                smack_set_catset(cipso.smk_catset, nlsp);
-        } else {
-                nlsp->attr.mls.lvl = smack_cipso_direct;
-                smack_set_catset(smack, nlsp);
-        }
-}
-
-/**
  * smack_netlabel - Set the secattr on a socket
  * @sk: the socket
  * @labeled: socket label scheme
@@ -1894,8 +1841,8 @@ static void smack_to_secattr(char *smack, struct netlbl_lsm_secattr *nlsp)
  */
 static int smack_netlabel(struct sock *sk, int labeled)
 {
+        struct smack_known *skp;
         struct socket_smack *ssp = sk->sk_security;
-        struct netlbl_lsm_secattr secattr;
         int rc = 0;
 
         /*
@@ -1913,10 +1860,8 @@ static int smack_netlabel(struct sock *sk, int labeled)
             labeled == SMACK_UNLABELED_SOCKET)
                 netlbl_sock_delattr(sk);
         else {
-                netlbl_secattr_init(&secattr);
-                smack_to_secattr(ssp->smk_out, &secattr);
-                rc = netlbl_sock_setattr(sk, sk->sk_family, &secattr);
-                netlbl_secattr_destroy(&secattr);
+                skp = smk_find_entry(ssp->smk_out);
+                rc = netlbl_sock_setattr(sk, sk->sk_family, &skp->smk_netlabel);
         }
 
         bh_unlock_sock(sk);
@@ -1989,7 +1934,7 @@ static int smack_inode_setsecurity(struct inode *inode, const char *name,
         struct socket *sock;
         int rc = 0;
 
-        if (value == NULL || size > SMK_LABELLEN || size == 0)
+        if (value == NULL || size > SMK_LONGLABEL || size == 0)
                 return -EACCES;
 
         sp = smk_import(value, size);
@@ -2785,7 +2730,7 @@ static int smack_setprocattr(struct task_struct *p, char *name,
         if (!capable(CAP_MAC_ADMIN))
                 return -EPERM;
 
-        if (value == NULL || size == 0 || size >= SMK_LABELLEN)
+        if (value == NULL || size == 0 || size >= SMK_LONGLABEL)
                 return -EINVAL;
 
         if (strcmp(name, "current") != 0)
@@ -2921,10 +2866,9 @@ static int smack_socket_sendmsg(struct socket *sock, struct msghdr *msg,
 static char *smack_from_secattr(struct netlbl_lsm_secattr *sap,
                                 struct socket_smack *ssp)
 {
-        struct smack_known *skp;
-        char smack[SMK_LABELLEN];
+        struct smack_known *kp;
         char *sp;
-        int pcat;
+        int found = 0;
 
         if ((sap->flags & NETLBL_SECATTR_MLS_LVL) != 0) {
                 /*
@@ -2932,59 +2876,27 @@ static char *smack_from_secattr(struct netlbl_lsm_secattr *sap,
                  * If there are flags but no level netlabel isn't
                  * behaving the way we expect it to.
                  *
-                 * Get the categories, if any
+                 * Look it up in the label table
                  * Without guidance regarding the smack value
                  * for the packet fall back on the network
                  * ambient value.
                  */
-                memset(smack, '\0', SMK_LABELLEN);
-                if ((sap->flags & NETLBL_SECATTR_MLS_CAT) != 0)
-                        for (pcat = -1;;) {
-                                pcat = netlbl_secattr_catmap_walk(
-                                        sap->attr.mls.cat, pcat + 1);
-                                if (pcat < 0)
-                                        break;
-                                smack_catset_bit(pcat, smack);
-                        }
-                /*
-                 * If it is CIPSO using smack direct mapping
-                 * we are already done. WeeHee.
-                 */
-                if (sap->attr.mls.lvl == smack_cipso_direct) {
-                        /*
-                         * The label sent is usually on the label list.
-                         *
-                         * If it is not we may still want to allow the
-                         * delivery.
-                         *
-                         * If the recipient is accepting all packets
-                         * because it is using the star ("*") label
-                         * for SMACK64IPIN provide the web ("@") label
-                         * so that a directed response will succeed.
-                         * This is not very correct from a MAC point
-                         * of view, but gets around the problem that
-                         * locking prevents adding the newly discovered
-                         * label to the list.
-                         * The case where the recipient is not using
-                         * the star label should obviously fail.
-                         * The easy way to do this is to provide the
-                         * star label as the subject label.
-                         */
-                        skp = smk_find_entry(smack);
-                        if (skp != NULL)
-                                return skp->smk_known;
-                        if (ssp != NULL &&
-                            ssp->smk_in == smack_known_star.smk_known)
-                                return smack_known_web.smk_known;
-                        return smack_known_star.smk_known;
+                rcu_read_lock();
+                list_for_each_entry(kp, &smack_known_list, list) {
+                        if (sap->attr.mls.lvl != kp->smk_netlabel.attr.mls.lvl)
+                                continue;
+                        if (memcmp(sap->attr.mls.cat,
+                                kp->smk_netlabel.attr.mls.cat,
+                                SMK_CIPSOLEN) != 0)
+                                continue;
+                        found = 1;
+                        break;
                 }
-                /*
-                 * Look it up in the supplied table if it is not
-                 * a direct mapping.
-                 */
-                sp = smack_from_cipso(sap->attr.mls.lvl, smack);
-                if (sp != NULL)
-                        return sp;
+                rcu_read_unlock();
+
+                if (found)
+                        return kp->smk_known;
+
                 if (ssp != NULL && ssp->smk_in == smack_known_star.smk_known)
                         return smack_known_web.smk_known;
                 return smack_known_star.smk_known;
@@ -3184,11 +3096,13 @@ static int smack_inet_conn_request(struct sock *sk, struct sk_buff *skb,
                                    struct request_sock *req)
 {
         u16 family = sk->sk_family;
+        struct smack_known *skp;
         struct socket_smack *ssp = sk->sk_security;
         struct netlbl_lsm_secattr secattr;
         struct sockaddr_in addr;
         struct iphdr *hdr;
         char *sp;
+        char *hsp;
         int rc;
         struct smk_audit_info ad;
 #ifdef CONFIG_AUDIT
@@ -3235,16 +3149,14 @@ static int smack_inet_conn_request(struct sock *sk, struct sk_buff *skb,
         hdr = ip_hdr(skb);
         addr.sin_addr.s_addr = hdr->saddr;
         rcu_read_lock();
-        if (smack_host_label(&addr) == NULL) {
-                rcu_read_unlock();
-                netlbl_secattr_init(&secattr);
-                smack_to_secattr(sp, &secattr);
-                rc = netlbl_req_setattr(req, &secattr);
-                netlbl_secattr_destroy(&secattr);
-        } else {
-                rcu_read_unlock();
+        hsp = smack_host_label(&addr);
+        rcu_read_unlock();
+
+        if (hsp == NULL) {
+                skp = smk_find_entry(sp);
+                rc = netlbl_req_setattr(req, &skp->smk_netlabel);
+        } else
                 netlbl_req_delattr(req);
-        }
 
         return rc;
 }
@@ -3669,15 +3581,6 @@ struct security_operations smack_ops = {
 static __init void init_smack_known_list(void)
 {
         /*
-         * Initialize CIPSO locks
-         */
-        spin_lock_init(&smack_known_huh.smk_cipsolock);
-        spin_lock_init(&smack_known_hat.smk_cipsolock);
-        spin_lock_init(&smack_known_star.smk_cipsolock);
-        spin_lock_init(&smack_known_floor.smk_cipsolock);
-        spin_lock_init(&smack_known_invalid.smk_cipsolock);
-        spin_lock_init(&smack_known_web.smk_cipsolock);
-        /*
          * Initialize rule list locks
          */
         mutex_init(&smack_known_huh.smk_rules_lock);