[NetLabel]: SELinux support

Add NetLabel support to the SELinux LSM and modify the
socket_post_create() LSM hook to return an error code.  The most
significant part of this patch is the addition of NetLabel hooks into
the following SELinux LSM hooks:

 * selinux_file_permission()
 * selinux_socket_sendmsg()
 * selinux_socket_post_create()
 * selinux_socket_sock_rcv_skb()
 * selinux_socket_getpeersec_stream()
 * selinux_socket_getpeersec_dgram()
 * selinux_sock_graft()
 * selinux_inet_conn_request()

The basic reasoning behind this patch is that outgoing packets are
"NetLabel'd" by labeling their socket and the NetLabel security
attributes are checked via the additional hook in
selinux_socket_sock_rcv_skb().  NetLabel itself is only a labeling
mechanism, similar to filesystem extended attributes, it is up to the
SELinux enforcement mechanism to perform the actual access checks.

In addition to the changes outlined above this patch also includes
some changes to the extended bitmap (ebitmap) and multi-level security
(mls) code to import and export SELinux TE/MLS attributes into and out
of NetLabel.

Signed-off-by: Paul Moore <paul.moore@hp.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

8 files changed, 993 insertions, 11 deletions

diff --git a/security/selinux/hooks.c b/security/selinux/hooks.c
index 33028b3b19ce..2a6bbb921e1e 100644
--- a/security/selinux/hooks.c
+++ b/security/selinux/hooks.c
@@ -12,6 +12,8 @@
  *  Copyright (C) 2003 Red Hat, Inc., James Morris <jmorris@redhat.com>
  *  Copyright (C) 2004-2005 Trusted Computer Solutions, Inc.
  *                          <dgoeddel@trustedcs.com>
+ *  Copyright (C) 2006 Hewlett-Packard Development Company, L.P.
+ *                     Paul Moore, <paul.moore@hp.com>
  *
  *      This program is free software; you can redistribute it and/or modify
  *      it under the terms of the GNU General Public License version 2,
@@ -74,6 +76,7 @@
 #include "objsec.h"
 #include "netif.h"
 #include "xfrm.h"
+#include "selinux_netlabel.h"
 
 #define XATTR_SELINUX_SUFFIX "selinux"
 #define XATTR_NAME_SELINUX XATTR_SECURITY_PREFIX XATTR_SELINUX_SUFFIX
@@ -2395,6 +2398,7 @@ static int selinux_inode_listsecurity(struct inode *inode, char *buffer, size_t
 
 static int selinux_file_permission(struct file *file, int mask)
 {
+        int rc;
         struct inode *inode = file->f_dentry->d_inode;
 
         if (!mask) {
@@ -2406,8 +2410,12 @@ static int selinux_file_permission(struct file *file, int mask)
         if ((file->f_flags & O_APPEND) && (mask & MAY_WRITE))
                 mask |= MAY_APPEND;
 
-        return file_has_perm(current, file,
-                             file_mask_to_av(inode->i_mode, mask));
+        rc = file_has_perm(current, file,
+                           file_mask_to_av(inode->i_mode, mask));
+        if (rc)
+                return rc;
+
+        return selinux_netlbl_inode_permission(inode, mask);
 }
 
 static int selinux_file_alloc_security(struct file *file)
@@ -3058,9 +3066,10 @@ out:
         return err;
 }
 
-static void selinux_socket_post_create(struct socket *sock, int family,
-                                       int type, int protocol, int kern)
+static int selinux_socket_post_create(struct socket *sock, int family,
+                                      int type, int protocol, int kern)
 {
+        int err = 0;
         struct inode_security_struct *isec;
         struct task_security_struct *tsec;
         struct sk_security_struct *sksec;
@@ -3077,9 +3086,12 @@ static void selinux_socket_post_create(struct socket *sock, int family,
         if (sock->sk) {
                 sksec = sock->sk->sk_security;
                 sksec->sid = isec->sid;
+                err = selinux_netlbl_socket_post_create(sock,
+                                                        family,
+                                                        isec->sid);
         }
 
-        return;
+        return err;
 }
 
 /* Range of port numbers used to automatically bind.
@@ -3260,7 +3272,13 @@ static int selinux_socket_accept(struct socket *sock, struct socket *newsock)
 static int selinux_socket_sendmsg(struct socket *sock, struct msghdr *msg,
                                   int size)
 {
-        return socket_has_perm(current, sock, SOCKET__WRITE);
+        int rc;
+
+        rc = socket_has_perm(current, sock, SOCKET__WRITE);
+        if (rc)
+                return rc;
+
+        return selinux_netlbl_inode_permission(SOCK_INODE(sock), MAY_WRITE);
 }
 
 static int selinux_socket_recvmsg(struct socket *sock, struct msghdr *msg,
@@ -3468,6 +3486,10 @@ static int selinux_socket_sock_rcv_skb(struct sock *sk, struct sk_buff *skb)
         if (err)
                 goto out;
 
+        err = selinux_netlbl_sock_rcv_skb(sksec, skb, &ad);
+        if (err)
+                goto out;
+
         err = selinux_xfrm_sock_rcv_skb(sksec->sid, skb, &ad);
 out:    
         return err;
@@ -3491,8 +3513,9 @@ static int selinux_socket_getpeersec_stream(struct socket *sock, char __user *op
                 peer_sid = ssec->peer_sid;
         }
         else if (isec->sclass == SECCLASS_TCP_SOCKET) {
-                peer_sid = selinux_socket_getpeer_stream(sock->sk);
-
+                peer_sid = selinux_netlbl_socket_getpeersec_stream(sock);
+                if (peer_sid == SECSID_NULL)
+                        peer_sid = selinux_socket_getpeer_stream(sock->sk);
                 if (peer_sid == SECSID_NULL) {
                         err = -ENOPROTOOPT;
                         goto out;
@@ -3532,8 +3555,11 @@ static int selinux_socket_getpeersec_dgram(struct socket *sock, struct sk_buff *
 
         if (sock && (sock->sk->sk_family == PF_UNIX))
                 selinux_get_inode_sid(SOCK_INODE(sock), &peer_secid);
-        else if (skb)
-                peer_secid = selinux_socket_getpeer_dgram(skb);
+        else if (skb) {
+                peer_secid = selinux_netlbl_socket_getpeersec_dgram(skb);
+                if (peer_secid == SECSID_NULL)
+                        peer_secid = selinux_socket_getpeer_dgram(skb);
+        }
 
         if (peer_secid == SECSID_NULL)
                 err = -EINVAL;
@@ -3578,6 +3604,8 @@ void selinux_sock_graft(struct sock* sk, struct socket *parent)
         struct sk_security_struct *sksec = sk->sk_security;
 
         isec->sid = sksec->sid;
+
+        selinux_netlbl_sock_graft(sk, parent);
 }
 
 int selinux_inet_conn_request(struct sock *sk, struct sk_buff *skb,
@@ -3585,9 +3613,15 @@ int selinux_inet_conn_request(struct sock *sk, struct sk_buff *skb,
 {
         struct sk_security_struct *sksec = sk->sk_security;
         int err;
-        u32 newsid = 0;
+        u32 newsid;
         u32 peersid;
 
+        newsid = selinux_netlbl_inet_conn_request(skb, sksec->sid);
+        if (newsid != SECSID_NULL) {
+                req->secid = newsid;
+                return 0;
+        }
+
         err = selinux_xfrm_decode_session(skb, &peersid, 0);
         BUG_ON(err);
 
diff --git a/security/selinux/include/objsec.h b/security/selinux/include/objsec.h
index 79b9e0af19a0..0a39bfd1319f 100644
--- a/security/selinux/include/objsec.h
+++ b/security/selinux/include/objsec.h
@@ -101,6 +101,14 @@ struct sk_security_struct {
         struct sock *sk;                /* back pointer to sk object */
         u32 sid;                        /* SID of this object */
         u32 peer_sid;                   /* SID of peer */
+#ifdef CONFIG_NETLABEL
+        u16 sclass;                     /* sock security class */
+        enum {                          /* NetLabel state */
+                NLBL_UNSET = 0,
+                NLBL_REQUIRE,
+                NLBL_LABELED,
+        } nlbl_state;
+#endif
 };
 
 struct key_security_struct {
diff --git a/security/selinux/include/selinux_netlabel.h b/security/selinux/include/selinux_netlabel.h
new file mode 100644
index 000000000000..88c463eef1e1
--- /dev/null
+++ b/security/selinux/include/selinux_netlabel.h
@@ -0,0 +1,125 @@
+/*
+ * SELinux interface to the NetLabel subsystem
+ *
+ * Author : Paul Moore <paul.moore@hp.com>
+ *
+ */
+
+/*
+ * (c) Copyright Hewlett-Packard Development Company, L.P., 2006
+ *
+ * This program is free software;  you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY;  without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
+ * the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program;  if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+#ifndef _SELINUX_NETLABEL_H_
+#define _SELINUX_NETLABEL_H_
+
+#ifdef CONFIG_NETLABEL
+void selinux_netlbl_cache_invalidate(void);
+int selinux_netlbl_socket_post_create(struct socket *sock,
+                                      int sock_family,
+                                      u32 sid);
+void selinux_netlbl_sock_graft(struct sock *sk, struct socket *sock);
+u32 selinux_netlbl_inet_conn_request(struct sk_buff *skb, u32 sock_sid);
+int selinux_netlbl_sock_rcv_skb(struct sk_security_struct *sksec,
+                                struct sk_buff *skb,
+                                struct avc_audit_data *ad);
+u32 selinux_netlbl_socket_getpeersec_stream(struct socket *sock);
+u32 selinux_netlbl_socket_getpeersec_dgram(struct sk_buff *skb);
+
+int __selinux_netlbl_inode_permission(struct inode *inode, int mask);
+/**
+ * selinux_netlbl_inode_permission - Verify the socket is NetLabel labeled
+ * @inode: the file descriptor's inode
+ * @mask: the permission mask
+ *
+ * Description:
+ * Looks at a file's inode and if it is marked as a socket protected by
+ * NetLabel then verify that the socket has been labeled, if not try to label
+ * the socket now with the inode's SID.  Returns zero on success, negative
+ * values on failure.
+ *
+ */
+static inline int selinux_netlbl_inode_permission(struct inode *inode,
+                                                  int mask)
+{
+        int rc = 0;
+        struct inode_security_struct *isec;
+        struct sk_security_struct *sksec;
+
+        if (!S_ISSOCK(inode->i_mode))
+                return 0;
+
+        isec = inode->i_security;
+        sksec = SOCKET_I(inode)->sk->sk_security;
+        down(&isec->sem);
+        if (unlikely(sksec->nlbl_state == NLBL_REQUIRE &&
+                     (mask & (MAY_WRITE | MAY_APPEND))))
+                rc = __selinux_netlbl_inode_permission(inode, mask);
+        up(&isec->sem);
+
+        return rc;
+}
+#else
+static inline void selinux_netlbl_cache_invalidate(void)
+{
+        return;
+}
+
+static inline int selinux_netlbl_socket_post_create(struct socket *sock,
+                                                    int sock_family,
+                                                    u32 sid)
+{
+        return 0;
+}
+
+static inline void selinux_netlbl_sock_graft(struct sock *sk,
+                                             struct socket *sock)
+{
+        return;
+}
+
+static inline u32 selinux_netlbl_inet_conn_request(struct sk_buff *skb,
+                                                   u32 sock_sid)
+{
+        return SECSID_NULL;
+}
+
+static inline int selinux_netlbl_sock_rcv_skb(struct sk_security_struct *sksec,
+                                              struct sk_buff *skb,
+                                              struct avc_audit_data *ad)
+{
+        return 0;
+}
+
+static inline u32 selinux_netlbl_socket_getpeersec_stream(struct socket *sock)
+{
+        return SECSID_NULL;
+}
+
+static inline u32 selinux_netlbl_socket_getpeersec_dgram(struct sk_buff *skb)
+{
+        return SECSID_NULL;
+}
+
+static inline int selinux_netlbl_inode_permission(struct inode *inode,
+                                                  int mask)
+{
+        return 0;
+}
+#endif /* CONFIG_NETLABEL */
+
+#endif
diff --git a/security/selinux/ss/ebitmap.c b/security/selinux/ss/ebitmap.c
index 47024a6e1844..4b915eb60c45 100644
--- a/security/selinux/ss/ebitmap.c
+++ b/security/selinux/ss/ebitmap.c
@@ -3,6 +3,14 @@
  *
  * Author : Stephen Smalley, <sds@epoch.ncsc.mil>
  */
+/*
+ * Updated: Hewlett-Packard <paul.moore@hp.com>
+ *
+ *      Added ebitmap_export() and ebitmap_import()
+ *
+ * (c) Copyright Hewlett-Packard Development Company, L.P., 2006
+ */
+
 #include <linux/kernel.h>
 #include <linux/slab.h>
 #include <linux/errno.h>
@@ -59,6 +67,142 @@ int ebitmap_cpy(struct ebitmap *dst, struct ebitmap *src)
         return 0;
 }
 
+/**
+ * ebitmap_export - Export an ebitmap to a unsigned char bitmap string
+ * @src: the ebitmap to export
+ * @dst: the resulting bitmap string
+ * @dst_len: length of dst in bytes
+ *
+ * Description:
+ * Allocate a buffer at least src->highbit bits long and export the extensible
+ * bitmap into the buffer.  The bitmap string will be in little endian format,
+ * i.e. LSB first.  The value returned in dst_len may not the true size of the
+ * buffer as the length of the buffer is rounded up to a multiple of MAPTYPE.
+ * The caller must free the buffer when finished. Returns zero on success,
+ * negative values on failure.
+ *
+ */
+int ebitmap_export(const struct ebitmap *src,
+                   unsigned char **dst,
+                   size_t *dst_len)
+{
+        size_t bitmap_len;
+        unsigned char *bitmap;
+        struct ebitmap_node *iter_node;
+        MAPTYPE node_val;
+        size_t bitmap_byte;
+        unsigned char bitmask;
+
+        bitmap_len = src->highbit / 8;
+        if (src->highbit % 7)
+                bitmap_len += 1;
+        if (bitmap_len == 0)
+                return -EINVAL;
+
+        bitmap = kzalloc((bitmap_len & ~(sizeof(MAPTYPE) - 1)) +
+                         sizeof(MAPTYPE),
+                         GFP_ATOMIC);
+        if (bitmap == NULL)
+                return -ENOMEM;
+
+        iter_node = src->node;
+        do {
+                bitmap_byte = iter_node->startbit / 8;
+                bitmask = 0x80;
+                node_val = iter_node->map;
+                do {
+                        if (bitmask == 0) {
+                                bitmap_byte++;
+                                bitmask = 0x80;
+                        }
+                        if (node_val & (MAPTYPE)0x01)
+                                bitmap[bitmap_byte] |= bitmask;
+                        node_val >>= 1;
+                        bitmask >>= 1;
+                } while (node_val > 0);
+                iter_node = iter_node->next;
+        } while (iter_node);
+
+        *dst = bitmap;
+        *dst_len = bitmap_len;
+        return 0;
+}
+
+/**
+ * ebitmap_import - Import an unsigned char bitmap string into an ebitmap
+ * @src: the bitmap string
+ * @src_len: the bitmap length in bytes
+ * @dst: the empty ebitmap
+ *
+ * Description:
+ * This function takes a little endian bitmap string in src and imports it into
+ * the ebitmap pointed to by dst.  Returns zero on success, negative values on
+ * failure.
+ *
+ */
+int ebitmap_import(const unsigned char *src,
+                   size_t src_len,
+                   struct ebitmap *dst)
+{
+        size_t src_off = 0;
+        struct ebitmap_node *node_new;
+        struct ebitmap_node *node_last = NULL;
+        size_t iter;
+        size_t iter_bit;
+        size_t iter_limit;
+        unsigned char src_byte;
+
+        do {
+                iter_limit = src_len - src_off;
+                if (iter_limit >= sizeof(MAPTYPE)) {
+                        if (*(MAPTYPE *)&src[src_off] == 0) {
+                                src_off += sizeof(MAPTYPE);
+                                continue;
+                        }
+                        iter_limit = sizeof(MAPTYPE);
+                } else {
+                        iter = src_off;
+                        src_byte = 0;
+                        do {
+                                src_byte |= src[iter++];
+                        } while (iter < src_len && src_byte == 0);
+                        if (src_byte == 0)
+                                break;
+                }
+
+                node_new = kzalloc(sizeof(*node_new), GFP_ATOMIC);
+                if (unlikely(node_new == NULL)) {
+                        ebitmap_destroy(dst);
+                        return -ENOMEM;
+                }
+                node_new->startbit = src_off * 8;
+                iter = 0;
+                do {
+                        src_byte = src[src_off++];
+                        iter_bit = iter++ * 8;
+                        while (src_byte != 0) {
+                                if (src_byte & 0x80)
+                                        node_new->map |= MAPBIT << iter_bit;
+                                iter_bit++;
+                                src_byte <<= 1;
+                        }
+                } while (iter < iter_limit);
+
+                if (node_last != NULL)
+                        node_last->next = node_new;
+                else
+                        dst->node = node_new;
+                node_last = node_new;
+        } while (src_off < src_len);
+
+        if (likely(node_last != NULL))
+                dst->highbit = node_last->startbit + MAPSIZE;
+        else
+                ebitmap_init(dst);
+
+        return 0;
+}
+
 int ebitmap_contains(struct ebitmap *e1, struct ebitmap *e2)
 {
         struct ebitmap_node *n1, *n2;
diff --git a/security/selinux/ss/ebitmap.h b/security/selinux/ss/ebitmap.h
index 8bf41055a6cb..da2d4651b10d 100644
--- a/security/selinux/ss/ebitmap.h
+++ b/security/selinux/ss/ebitmap.h
@@ -69,6 +69,12 @@ static inline int ebitmap_node_get_bit(struct ebitmap_node * n,
 
 int ebitmap_cmp(struct ebitmap *e1, struct ebitmap *e2);
 int ebitmap_cpy(struct ebitmap *dst, struct ebitmap *src);
+int ebitmap_export(const struct ebitmap *src,
+                   unsigned char **dst,
+                   size_t *dst_len);
+int ebitmap_import(const unsigned char *src,
+                   size_t src_len,
+                   struct ebitmap *dst);
 int ebitmap_contains(struct ebitmap *e1, struct ebitmap *e2);
 int ebitmap_get_bit(struct ebitmap *e, unsigned long bit);
 int ebitmap_set_bit(struct ebitmap *e, unsigned long bit, int value);
diff --git a/security/selinux/ss/mls.c b/security/selinux/ss/mls.c
index e15f7e0399b8..119bd6078ba1 100644
--- a/security/selinux/ss/mls.c
+++ b/security/selinux/ss/mls.c
@@ -10,6 +10,13 @@
  *
  * Copyright (C) 2004-2006 Trusted Computer Solutions, Inc.
  */
+/*
+ * Updated: Hewlett-Packard <paul.moore@hp.com>
+ *
+ *      Added support to import/export the MLS label
+ *
+ * (c) Copyright Hewlett-Packard Development Company, L.P., 2006
+ */
 
 #include <linux/kernel.h>
 #include <linux/slab.h>
@@ -565,3 +572,152 @@ int mls_compute_sid(struct context *scontext,
         return -EINVAL;
 }
 
+/**
+ * mls_export_lvl - Export the MLS sensitivity levels
+ * @context: the security context
+ * @low: the low sensitivity level
+ * @high: the high sensitivity level
+ *
+ * Description:
+ * Given the security context copy the low MLS sensitivity level into lvl_low
+ * and the high sensitivity level in lvl_high.  The MLS levels are only
+ * exported if the pointers are not NULL, if they are NULL then that level is
+ * not exported.
+ *
+ */
+void mls_export_lvl(const struct context *context, u32 *low, u32 *high)
+{
+        if (!selinux_mls_enabled)
+                return;
+
+        if (low != NULL)
+                *low = context->range.level[0].sens - 1;
+        if (high != NULL)
+                *high = context->range.level[1].sens - 1;
+}
+
+/**
+ * mls_import_lvl - Import the MLS sensitivity levels
+ * @context: the security context
+ * @low: the low sensitivity level
+ * @high: the high sensitivity level
+ *
+ * Description:
+ * Given the security context and the two sensitivty levels, set the MLS levels
+ * in the context according the two given as parameters.  Returns zero on
+ * success, negative values on failure.
+ *
+ */
+void mls_import_lvl(struct context *context, u32 low, u32 high)
+{
+        if (!selinux_mls_enabled)
+                return;
+
+        context->range.level[0].sens = low + 1;
+        context->range.level[1].sens = high + 1;
+}
+
+/**
+ * mls_export_cat - Export the MLS categories
+ * @context: the security context
+ * @low: the low category
+ * @low_len: length of the cat_low bitmap in bytes
+ * @high: the high category
+ * @high_len: length of the cat_high bitmap in bytes
+ *
+ * Description:
+ * Given the security context export the low MLS category bitmap into cat_low
+ * and the high category bitmap into cat_high.  The MLS categories are only
+ * exported if the pointers are not NULL, if they are NULL then that level is
+ * not exported.  The caller is responsibile for freeing the memory when
+ * finished.  Returns zero on success, negative values on failure.
+ *
+ */
+int mls_export_cat(const struct context *context,
+                   unsigned char **low,
+                   size_t *low_len,
+                   unsigned char **high,
+                   size_t *high_len)
+{
+        int rc = -EPERM;
+
+        if (!selinux_mls_enabled)
+                return 0;
+
+        if (low != NULL) {
+                rc = ebitmap_export(&context->range.level[0].cat,
+                                    low,
+                                    low_len);
+                if (rc != 0)
+                        goto export_cat_failure;
+        }
+        if (high != NULL) {
+                rc = ebitmap_export(&context->range.level[1].cat,
+                                    high,
+                                    high_len);
+                if (rc != 0)
+                        goto export_cat_failure;
+        }
+
+        return 0;
+
+export_cat_failure:
+        if (low != NULL)
+                kfree(*low);
+        if (high != NULL)
+                kfree(*high);
+        return rc;
+}
+
+/**
+ * mls_import_cat - Import the MLS categories
+ * @context: the security context
+ * @low: the low category
+ * @low_len: length of the cat_low bitmap in bytes
+ * @high: the high category
+ * @high_len: length of the cat_high bitmap in bytes
+ *
+ * Description:
+ * Given the security context and the two category bitmap strings import the
+ * categories into the security context.  The MLS categories are only imported
+ * if the pointers are not NULL, if they are NULL they are skipped.  Returns
+ * zero on success, negative values on failure.
+ *
+ */
+int mls_import_cat(struct context *context,
+                   const unsigned char *low,
+                   size_t low_len,
+                   const unsigned char *high,
+                   size_t high_len)
+{
+        int rc = -EPERM;
+
+        if (!selinux_mls_enabled)
+                return 0;
+
+        if (low != NULL) {
+                rc = ebitmap_import(low,
+                                    low_len,
+                                    &context->range.level[0].cat);
+                if (rc != 0)
+                        goto import_cat_failure;
+        }
+        if (high != NULL) {
+                if (high == low)
+                        rc = ebitmap_cpy(&context->range.level[1].cat,
+                                         &context->range.level[0].cat);
+                else
+                        rc = ebitmap_import(high,
+                                            high_len,
+                                            &context->range.level[1].cat);
+                if (rc != 0)
+                        goto import_cat_failure;
+        }
+
+        return 0;
+
+import_cat_failure:
+        ebitmap_destroy(&context->range.level[0].cat);
+        ebitmap_destroy(&context->range.level[1].cat);
+        return rc;
+}
diff --git a/security/selinux/ss/mls.h b/security/selinux/ss/mls.h
index 90c5e88987fa..df6032c6d492 100644
--- a/security/selinux/ss/mls.h
+++ b/security/selinux/ss/mls.h
@@ -10,6 +10,13 @@
  *
  * Copyright (C) 2004-2006 Trusted Computer Solutions, Inc.
  */
+/*
+ * Updated: Hewlett-Packard <paul.moore@hp.com>
+ *
+ *      Added support to import/export the MLS label
+ *
+ * (c) Copyright Hewlett-Packard Development Company, L.P., 2006
+ */
 
 #ifndef _SS_MLS_H_
 #define _SS_MLS_H_
@@ -62,5 +69,19 @@ int mls_compute_sid(struct context *scontext,
 int mls_setup_user_range(struct context *fromcon, struct user_datum *user,
                          struct context *usercon);
 
+void mls_export_lvl(const struct context *context, u32 *low, u32 *high);
+void mls_import_lvl(struct context *context, u32 low, u32 high);
+
+int mls_export_cat(const struct context *context,
+                   unsigned char **low,
+                   size_t *low_len,
+                   unsigned char **high,
+                   size_t *high_len);
+int mls_import_cat(struct context *context,
+                   const unsigned char *low,
+                   size_t low_len,
+                   const unsigned char *high,
+                   size_t high_len);
+
 #endif  /* _SS_MLS_H */
 
diff --git a/security/selinux/ss/services.c b/security/selinux/ss/services.c
index b00ec69f0ffd..910afa1ffc31 100644
--- a/security/selinux/ss/services.c
+++ b/security/selinux/ss/services.c
@@ -13,6 +13,11 @@
  *
  *      Added conditional policy language extensions
  *
+ * Updated: Hewlett-Packard <paul.moore@hp.com>
+ *
+ *      Added support for NetLabel
+ *
+ * Copyright (C) 2006 Hewlett-Packard Development Company, L.P.
  * Copyright (C) 2004-2006 Trusted Computer Solutions, Inc.
  * Copyright (C) 2003 - 2004 Tresys Technology, LLC
  * Copyright (C) 2003 Red Hat, Inc., James Morris <jmorris@redhat.com>
@@ -29,6 +34,8 @@
 #include <linux/sched.h>
 #include <linux/audit.h>
 #include <linux/mutex.h>
+#include <net/sock.h>
+#include <net/netlabel.h>
 
 #include "flask.h"
 #include "avc.h"
@@ -40,6 +47,8 @@
 #include "services.h"
 #include "conditional.h"
 #include "mls.h"
+#include "objsec.h"
+#include "selinux_netlabel.h"
 
 extern void selnl_notify_policyload(u32 seqno);
 unsigned int policydb_loaded_version;
@@ -1241,6 +1250,7 @@ int security_load_policy(void *data, size_t len)
                 selinux_complete_init();
                 avc_ss_reset(seqno);
                 selnl_notify_policyload(seqno);
+                selinux_netlbl_cache_invalidate();
                 return 0;
         }
 
@@ -1295,6 +1305,7 @@ int security_load_policy(void *data, size_t len)
 
         avc_ss_reset(seqno);
         selnl_notify_policyload(seqno);
+        selinux_netlbl_cache_invalidate();
 
         return 0;
 
@@ -2133,3 +2144,480 @@ void selinux_audit_set_callback(int (*callback)(void))
 {
         aurule_callback = callback;
 }
+
+#ifdef CONFIG_NETLABEL
+/*
+ * This is the structure we store inside the NetLabel cache block.
+ */
+#define NETLBL_CACHE(x)           ((struct netlbl_cache *)(x))
+#define NETLBL_CACHE_T_NONE       0
+#define NETLBL_CACHE_T_SID        1
+#define NETLBL_CACHE_T_MLS        2
+struct netlbl_cache {
+        u32 type;
+        union {
+                u32 sid;
+                struct mls_range mls_label;
+        } data;
+};
+
+/**
+ * selinux_netlbl_cache_free - Free the NetLabel cached data
+ * @data: the data to free
+ *
+ * Description:
+ * This function is intended to be used as the free() callback inside the
+ * netlbl_lsm_cache structure.
+ *
+ */
+static void selinux_netlbl_cache_free(const void *data)
+{
+        struct netlbl_cache *cache = NETLBL_CACHE(data);
+        switch (cache->type) {
+        case NETLBL_CACHE_T_MLS:
+                ebitmap_destroy(&cache->data.mls_label.level[0].cat);
+                break;
+        }
+        kfree(data);
+}
+
+/**
+ * selinux_netlbl_cache_add - Add an entry to the NetLabel cache
+ * @skb: the packet
+ * @ctx: the SELinux context
+ *
+ * Description:
+ * Attempt to cache the context in @ctx, which was derived from the packet in
+ * @skb, in the NetLabel subsystem cache.
+ *
+ */
+static void selinux_netlbl_cache_add(struct sk_buff *skb, struct context *ctx)
+{
+        struct netlbl_cache *cache = NULL;
+        struct netlbl_lsm_secattr secattr;
+
+        netlbl_secattr_init(&secattr);
+
+        cache = kzalloc(sizeof(*cache), GFP_ATOMIC);
+        if (cache == NULL)
+                goto netlbl_cache_add_failure;
+        secattr.cache.free = selinux_netlbl_cache_free;
+        secattr.cache.data = (void *)cache;
+
+        cache->type = NETLBL_CACHE_T_MLS;
+        if (ebitmap_cpy(&cache->data.mls_label.level[0].cat,
+                        &ctx->range.level[0].cat) != 0)
+                goto netlbl_cache_add_failure;
+        cache->data.mls_label.level[1].cat.highbit =
+                cache->data.mls_label.level[0].cat.highbit;
+        cache->data.mls_label.level[1].cat.node =
+                cache->data.mls_label.level[0].cat.node;
+        cache->data.mls_label.level[0].sens = ctx->range.level[0].sens;
+        cache->data.mls_label.level[1].sens = ctx->range.level[0].sens;
+
+        if (netlbl_cache_add(skb, &secattr) != 0)
+                goto netlbl_cache_add_failure;
+
+        return;
+
+netlbl_cache_add_failure:
+        netlbl_secattr_destroy(&secattr, 1);
+}
+
+/**
+ * selinux_netlbl_cache_invalidate - Invalidate the NetLabel cache
+ *
+ * Description:
+ * Invalidate the NetLabel security attribute mapping cache.
+ *
+ */
+void selinux_netlbl_cache_invalidate(void)
+{
+        netlbl_cache_invalidate();
+}
+
+/**
+ * selinux_netlbl_secattr_to_sid - Convert a NetLabel secattr to a SELinux SID
+ * @skb: the network packet
+ * @secattr: the NetLabel packet security attributes
+ * @base_sid: the SELinux SID to use as a context for MLS only attributes
+ * @sid: the SELinux SID
+ *
+ * Description:
+ * Convert the given NetLabel packet security attributes in @secattr into a
+ * SELinux SID.  If the @secattr field does not contain a full SELinux
+ * SID/context then use the context in @base_sid as the foundation.  If @skb
+ * is not NULL attempt to cache as much data as possibile.  Returns zero on
+ * success, negative values on failure.
+ *
+ */
+static int selinux_netlbl_secattr_to_sid(struct sk_buff *skb,
+                                         struct netlbl_lsm_secattr *secattr,
+                                         u32 base_sid,
+                                         u32 *sid)
+{
+        int rc = -EIDRM;
+        struct context *ctx;
+        struct context ctx_new;
+        struct netlbl_cache *cache;
+
+        POLICY_RDLOCK;
+
+        if (secattr->cache.data) {
+                cache = NETLBL_CACHE(secattr->cache.data);
+                switch (cache->type) {
+                case NETLBL_CACHE_T_SID:
+                        *sid = cache->data.sid;
+                        rc = 0;
+                        break;
+                case NETLBL_CACHE_T_MLS:
+                        ctx = sidtab_search(&sidtab, base_sid);
+                        if (ctx == NULL)
+                                goto netlbl_secattr_to_sid_return;
+
+                        ctx_new.user = ctx->user;
+                        ctx_new.role = ctx->role;
+                        ctx_new.type = ctx->type;
+                        ctx_new.range.level[0].sens =
+                                cache->data.mls_label.level[0].sens;
+                        ctx_new.range.level[0].cat.highbit =
+                                cache->data.mls_label.level[0].cat.highbit;
+                        ctx_new.range.level[0].cat.node =
+                                cache->data.mls_label.level[0].cat.node;
+                        ctx_new.range.level[1].sens =
+                                cache->data.mls_label.level[1].sens;
+                        ctx_new.range.level[1].cat.highbit =
+                                cache->data.mls_label.level[1].cat.highbit;
+                        ctx_new.range.level[1].cat.node =
+                                cache->data.mls_label.level[1].cat.node;
+
+                        rc = sidtab_context_to_sid(&sidtab, &ctx_new, sid);
+                        break;
+                default:
+                        goto netlbl_secattr_to_sid_return;
+                }
+        } else if (secattr->mls_lvl_vld) {
+                ctx = sidtab_search(&sidtab, base_sid);
+                if (ctx == NULL)
+                        goto netlbl_secattr_to_sid_return;
+
+                ctx_new.user = ctx->user;
+                ctx_new.role = ctx->role;
+                ctx_new.type = ctx->type;
+                mls_import_lvl(&ctx_new, secattr->mls_lvl, secattr->mls_lvl);
+                if (secattr->mls_cat) {
+                        if (mls_import_cat(&ctx_new,
+                                           secattr->mls_cat,
+                                           secattr->mls_cat_len,
+                                           NULL,
+                                           0) != 0)
+                                goto netlbl_secattr_to_sid_return;
+                        ctx_new.range.level[1].cat.highbit =
+                                ctx_new.range.level[0].cat.highbit;
+                        ctx_new.range.level[1].cat.node =
+                                ctx_new.range.level[0].cat.node;
+                } else {
+                        ebitmap_init(&ctx_new.range.level[0].cat);
+                        ebitmap_init(&ctx_new.range.level[1].cat);
+                }
+                if (mls_context_isvalid(&policydb, &ctx_new) != 1)
+                        goto netlbl_secattr_to_sid_return_cleanup;
+
+                rc = sidtab_context_to_sid(&sidtab, &ctx_new, sid);
+                if (rc != 0)
+                        goto netlbl_secattr_to_sid_return_cleanup;
+
+                if (skb != NULL)
+                        selinux_netlbl_cache_add(skb, &ctx_new);
+                ebitmap_destroy(&ctx_new.range.level[0].cat);
+        } else {
+                *sid = SECINITSID_UNLABELED;
+                rc = 0;
+        }
+
+netlbl_secattr_to_sid_return:
+        POLICY_RDUNLOCK;
+        return rc;
+netlbl_secattr_to_sid_return_cleanup:
+        ebitmap_destroy(&ctx_new.range.level[0].cat);
+        goto netlbl_secattr_to_sid_return;
+}
+
+/**
+ * selinux_netlbl_skbuff_getsid - Get the sid of a packet using NetLabel
+ * @skb: the packet
+ * @base_sid: the SELinux SID to use as a context for MLS only attributes
+ * @sid: the SID
+ *
+ * Description:
+ * Call the NetLabel mechanism to get the security attributes of the given
+ * packet and use those attributes to determine the correct context/SID to
+ * assign to the packet.  Returns zero on success, negative values on failure.
+ *
+ */
+static int selinux_netlbl_skbuff_getsid(struct sk_buff *skb,
+                                        u32 base_sid,
+                                        u32 *sid)
+{
+        int rc;
+        struct netlbl_lsm_secattr secattr;
+
+        netlbl_secattr_init(&secattr);
+        rc = netlbl_skbuff_getattr(skb, &secattr);
+        if (rc == 0)
+                rc = selinux_netlbl_secattr_to_sid(skb,
+                                                   &secattr,
+                                                   base_sid,
+                                                   sid);
+        netlbl_secattr_destroy(&secattr, 0);
+
+        return rc;
+}
+
+/**
+ * selinux_netlbl_socket_setsid - Label a socket using the NetLabel mechanism
+ * @sock: the socket to label
+ * @sid: the SID to use
+ *
+ * Description:
+ * Attempt to label a socket using the NetLabel mechanism using the given
+ * SID.  Returns zero values on success, negative values on failure.
+ *
+ */
+static int selinux_netlbl_socket_setsid(struct socket *sock, u32 sid)
+{
+        int rc = -ENOENT;
+        struct sk_security_struct *sksec = sock->sk->sk_security;
+        struct netlbl_lsm_secattr secattr;
+        struct context *ctx;
+
+        if (!ss_initialized)
+                return 0;
+
+        POLICY_RDLOCK;
+
+        ctx = sidtab_search(&sidtab, sid);
+        if (ctx == NULL)
+                goto netlbl_socket_setsid_return;
+
+        netlbl_secattr_init(&secattr);
+        secattr.domain = kstrdup(policydb.p_type_val_to_name[ctx->type - 1],
+                                 GFP_ATOMIC);
+        mls_export_lvl(ctx, &secattr.mls_lvl, NULL);
+        secattr.mls_lvl_vld = 1;
+        mls_export_cat(ctx,
+                       &secattr.mls_cat,
+                       &secattr.mls_cat_len,
+                       NULL,
+                       NULL);
+
+        rc = netlbl_socket_setattr(sock, &secattr);
+        if (rc == 0)
+                sksec->nlbl_state = NLBL_LABELED;
+
+        netlbl_secattr_destroy(&secattr, 0);
+
+netlbl_socket_setsid_return:
+        POLICY_RDUNLOCK;
+        return rc;
+}
+
+/**
+ * selinux_netlbl_socket_post_create - Label a socket using NetLabel
+ * @sock: the socket to label
+ * @sock_family: the socket family
+ * @sid: the SID to use
+ *
+ * Description:
+ * Attempt to label a socket using the NetLabel mechanism using the given
+ * SID.  Returns zero values on success, negative values on failure.
+ *
+ */
+int selinux_netlbl_socket_post_create(struct socket *sock,
+                                      int sock_family,
+                                      u32 sid)
+{
+        struct inode_security_struct *isec = SOCK_INODE(sock)->i_security;
+        struct sk_security_struct *sksec = sock->sk->sk_security;
+
+        if (sock_family != PF_INET)
+                return 0;
+
+        sksec->sclass = isec->sclass;
+        sksec->nlbl_state = NLBL_REQUIRE;
+        return selinux_netlbl_socket_setsid(sock, sid);
+}
+
+/**
+ * selinux_netlbl_sock_graft - Netlabel the new socket
+ * @sk: the new connection
+ * @sock: the new socket
+ *
+ * Description:
+ * The connection represented by @sk is being grafted onto @sock so set the
+ * socket's NetLabel to match the SID of @sk.
+ *
+ */
+void selinux_netlbl_sock_graft(struct sock *sk, struct socket *sock)
+{
+        struct inode_security_struct *isec = SOCK_INODE(sock)->i_security;
+        struct sk_security_struct *sksec = sk->sk_security;
+
+        if (sk->sk_family != PF_INET)
+                return;
+
+        sksec->nlbl_state = NLBL_REQUIRE;
+        sksec->peer_sid = sksec->sid;
+        sksec->sclass = isec->sclass;
+
+        /* Try to set the NetLabel on the socket to save time later, if we fail
+         * here we will pick up the pieces in later calls to
+         * selinux_netlbl_inode_permission(). */
+        selinux_netlbl_socket_setsid(sock, sksec->sid);
+}
+
+/**
+ * selinux_netlbl_inet_conn_request - Handle a new connection request
+ * @skb: the packet
+ * @sock_sid: the SID of the parent socket
+ *
+ * Description:
+ * If present, use the security attributes of the packet in @skb and the
+ * parent sock's SID to arrive at a SID for the new child sock.  Returns the
+ * SID of the connection or SECSID_NULL on failure.
+ *
+ */
+u32 selinux_netlbl_inet_conn_request(struct sk_buff *skb, u32 sock_sid)
+{
+        int rc;
+        u32 peer_sid;
+
+        rc = selinux_netlbl_skbuff_getsid(skb, sock_sid, &peer_sid);
+        if (rc != 0)
+                return SECSID_NULL;
+
+        if (peer_sid == SECINITSID_UNLABELED)
+                return SECSID_NULL;
+
+        return peer_sid;
+}
+
+/**
+ * __selinux_netlbl_inode_permission - Label a socket using NetLabel
+ * @inode: the file descriptor's inode
+ * @mask: the permission mask
+ *
+ * Description:
+ * Try to label a socket with the inode's SID using NetLabel.  Returns zero on
+ * success, negative values on failure.
+ *
+ */
+int __selinux_netlbl_inode_permission(struct inode *inode, int mask)
+{
+        int rc;
+        struct socket *sock = SOCKET_I(inode);
+        struct sk_security_struct *sksec = sock->sk->sk_security;
+
+        lock_sock(sock->sk);
+        rc = selinux_netlbl_socket_setsid(sock, sksec->sid);
+        release_sock(sock->sk);
+
+        return rc;
+}
+
+/**
+ * selinux_netlbl_sock_rcv_skb - Do an inbound access check using NetLabel
+ * @sksec: the sock's sk_security_struct
+ * @skb: the packet
+ * @ad: the audit data
+ *
+ * Description:
+ * Fetch the NetLabel security attributes from @skb and perform an access check
+ * against the receiving socket.  Returns zero on success, negative values on
+ * error.
+ *
+ */
+int selinux_netlbl_sock_rcv_skb(struct sk_security_struct *sksec,
+                                struct sk_buff *skb,
+                                struct avc_audit_data *ad)
+{
+        int rc;
+        u32 netlbl_sid;
+        u32 recv_perm;
+
+        rc = selinux_netlbl_skbuff_getsid(skb, sksec->sid, &netlbl_sid);
+        if (rc != 0)
+                return rc;
+
+        if (netlbl_sid == SECINITSID_UNLABELED)
+                return 0;
+
+        switch (sksec->sclass) {
+        case SECCLASS_UDP_SOCKET:
+                recv_perm = UDP_SOCKET__RECV_MSG;
+                break;
+        case SECCLASS_TCP_SOCKET:
+                recv_perm = TCP_SOCKET__RECV_MSG;
+                break;
+        default:
+                recv_perm = RAWIP_SOCKET__RECV_MSG;
+        }
+
+        rc = avc_has_perm(sksec->sid,
+                          netlbl_sid,
+                          sksec->sclass,
+                          recv_perm,
+                          ad);
+        if (rc == 0)
+                return 0;
+
+        netlbl_skbuff_err(skb, rc);
+        return rc;
+}
+
+/**
+ * selinux_netlbl_socket_peersid - Return the peer SID of a connected socket
+ * @sock: the socket
+ *
+ * Description:
+ * Examine @sock to find the connected peer's SID.  Returns the SID on success
+ * or SECSID_NULL on error.
+ *
+ */
+u32 selinux_netlbl_socket_getpeersec_stream(struct socket *sock)
+{
+        struct sk_security_struct *sksec = sock->sk->sk_security;
+
+        if (sksec->peer_sid == SECINITSID_UNLABELED)
+                return SECSID_NULL;
+
+        return sksec->peer_sid;
+}
+
+/**
+ * selinux_netlbl_socket_getpeersec_dgram - Return the SID of a NetLabel packet
+ * @skb: the packet
+ *
+ * Description:
+ * Examine @skb to find the SID assigned to it by NetLabel.  Returns the SID on
+ * success, SECSID_NULL on error.
+ *
+ */
+u32 selinux_netlbl_socket_getpeersec_dgram(struct sk_buff *skb)
+{
+        int peer_sid;
+        struct sock *sk = skb->sk;
+        struct inode_security_struct *isec;
+
+        if (sk == NULL || sk->sk_socket == NULL)
+                return SECSID_NULL;
+
+        isec = SOCK_INODE(sk->sk_socket)->i_security;
+        if (selinux_netlbl_skbuff_getsid(skb, isec->sid, &peer_sid) != 0)
+                return SECSID_NULL;
+        if (peer_sid == SECINITSID_UNLABELED)
+                return SECSID_NULL;
+
+        return peer_sid;
+}
+#endif /* CONFIG_NETLABEL */