0fa2be4149e80db80741eb633d9c7b27f1b87d88
[linux-2.6.git] / security / selinux / netlabel.c
1 /*
2  * SELinux NetLabel Support
3  *
4  * This file provides the necessary glue to tie NetLabel into the SELinux
5  * subsystem.
6  *
7  * Author: Paul Moore <paul.moore@hp.com>
8  *
9  */
10
11 /*
12  * (c) Copyright Hewlett-Packard Development Company, L.P., 2007
13  *
14  * This program is free software;  you can redistribute it and/or modify
15  * it under the terms of the GNU General Public License as published by
16  * the Free Software Foundation; either version 2 of the License, or
17  * (at your option) any later version.
18  *
19  * This program is distributed in the hope that it will be useful,
20  * but WITHOUT ANY WARRANTY;  without even the implied warranty of
21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
22  * the GNU General Public License for more details.
23  *
24  * You should have received a copy of the GNU General Public License
25  * along with this program;  if not, write to the Free Software
26  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
27  *
28  */
29
30 #include <linux/spinlock.h>
31 #include <linux/rcupdate.h>
32 #include <net/sock.h>
33 #include <net/netlabel.h>
34
35 #include "objsec.h"
36 #include "security.h"
37
38 /**
39  * selinux_netlbl_sidlookup_cached - Cache a SID lookup
40  * @skb: the packet
41  * @secattr: the NetLabel security attributes
42  * @sid: the SID
43  *
44  * Description:
45  * Query the SELinux security server to lookup the correct SID for the given
46  * security attributes.  If the query is successful, cache the result to speed
47  * up future lookups.  Returns zero on success, negative values on failure.
48  *
49  */
50 static int selinux_netlbl_sidlookup_cached(struct sk_buff *skb,
51                                            struct netlbl_lsm_secattr *secattr,
52                                            u32 *sid)
53 {
54         int rc;
55
56         rc = security_netlbl_secattr_to_sid(secattr, sid);
57         if (rc == 0 &&
58             (secattr->flags & NETLBL_SECATTR_CACHEABLE) &&
59             (secattr->flags & NETLBL_SECATTR_CACHE))
60                 netlbl_cache_add(skb, secattr);
61
62         return rc;
63 }
64
65 /**
66  * selinux_netlbl_sock_setsid - Label a socket using the NetLabel mechanism
67  * @sk: the socket to label
68  * @sid: the SID to use
69  *
70  * Description:
71  * Attempt to label a socket using the NetLabel mechanism using the given
72  * SID.  Returns zero values on success, negative values on failure.  The
73  * caller is responsibile for calling rcu_read_lock() before calling this
74  * this function and rcu_read_unlock() after this function returns.
75  *
76  */
77 static int selinux_netlbl_sock_setsid(struct sock *sk, u32 sid)
78 {
79         int rc;
80         struct sk_security_struct *sksec = sk->sk_security;
81         struct netlbl_lsm_secattr secattr;
82
83         netlbl_secattr_init(&secattr);
84
85         rc = security_netlbl_sid_to_secattr(sid, &secattr);
86         if (rc != 0)
87                 goto sock_setsid_return;
88         rc = netlbl_sock_setattr(sk, &secattr);
89         if (rc == 0) {
90                 spin_lock_bh(&sksec->nlbl_lock);
91                 sksec->nlbl_state = NLBL_LABELED;
92                 spin_unlock_bh(&sksec->nlbl_lock);
93         }
94
95 sock_setsid_return:
96         netlbl_secattr_destroy(&secattr);
97         return rc;
98 }
99
100 /**
101  * selinux_netlbl_cache_invalidate - Invalidate the NetLabel cache
102  *
103  * Description:
104  * Invalidate the NetLabel security attribute mapping cache.
105  *
106  */
107 void selinux_netlbl_cache_invalidate(void)
108 {
109         netlbl_cache_invalidate();
110 }
111
112 /**
113  * selinux_netlbl_sk_security_reset - Reset the NetLabel fields
114  * @ssec: the sk_security_struct
115  * @family: the socket family
116  *
117  * Description:
118  * Called when the NetLabel state of a sk_security_struct needs to be reset.
119  * The caller is responsibile for all the NetLabel sk_security_struct locking.
120  *
121  */
122 void selinux_netlbl_sk_security_reset(struct sk_security_struct *ssec,
123                                       int family)
124 {
125         if (family == PF_INET)
126                 ssec->nlbl_state = NLBL_REQUIRE;
127         else
128                 ssec->nlbl_state = NLBL_UNSET;
129 }
130
131 /**
132  * selinux_netlbl_sk_security_init - Setup the NetLabel fields
133  * @ssec: the sk_security_struct
134  * @family: the socket family
135  *
136  * Description:
137  * Called when a new sk_security_struct is allocated to initialize the NetLabel
138  * fields.
139  *
140  */
141 void selinux_netlbl_sk_security_init(struct sk_security_struct *ssec,
142                                      int family)
143 {
144         /* No locking needed, we are the only one who has access to ssec */
145         selinux_netlbl_sk_security_reset(ssec, family);
146         spin_lock_init(&ssec->nlbl_lock);
147 }
148
149 /**
150  * selinux_netlbl_sk_security_clone - Copy the NetLabel fields
151  * @ssec: the original sk_security_struct
152  * @newssec: the cloned sk_security_struct
153  *
154  * Description:
155  * Clone the NetLabel specific sk_security_struct fields from @ssec to
156  * @newssec.
157  *
158  */
159 void selinux_netlbl_sk_security_clone(struct sk_security_struct *ssec,
160                                       struct sk_security_struct *newssec)
161 {
162         /* We don't need to take newssec->nlbl_lock because we are the only
163          * thread with access to newssec, but we do need to take the RCU read
164          * lock as other threads could have access to ssec */
165         rcu_read_lock();
166         selinux_netlbl_sk_security_reset(newssec, ssec->sk->sk_family);
167         rcu_read_unlock();
168 }
169
170 /**
171  * selinux_netlbl_skbuff_getsid - Get the sid of a packet using NetLabel
172  * @skb: the packet
173  * @family: protocol family
174  * @type: NetLabel labeling protocol type
175  * @sid: the SID
176  *
177  * Description:
178  * Call the NetLabel mechanism to get the security attributes of the given
179  * packet and use those attributes to determine the correct context/SID to
180  * assign to the packet.  Returns zero on success, negative values on failure.
181  *
182  */
183 int selinux_netlbl_skbuff_getsid(struct sk_buff *skb,
184                                  u16 family,
185                                  u32 *type,
186                                  u32 *sid)
187 {
188         int rc;
189         struct netlbl_lsm_secattr secattr;
190
191         if (!netlbl_enabled()) {
192                 *sid = SECSID_NULL;
193                 return 0;
194         }
195
196         netlbl_secattr_init(&secattr);
197         rc = netlbl_skbuff_getattr(skb, family, &secattr);
198         if (rc == 0 && secattr.flags != NETLBL_SECATTR_NONE)
199                 rc = selinux_netlbl_sidlookup_cached(skb, &secattr, sid);
200         else
201                 *sid = SECSID_NULL;
202         *type = secattr.type;
203         netlbl_secattr_destroy(&secattr);
204
205         return rc;
206 }
207
208 /**
209  * selinux_netlbl_sock_graft - Netlabel the new socket
210  * @sk: the new connection
211  * @sock: the new socket
212  *
213  * Description:
214  * The connection represented by @sk is being grafted onto @sock so set the
215  * socket's NetLabel to match the SID of @sk.
216  *
217  */
218 void selinux_netlbl_sock_graft(struct sock *sk, struct socket *sock)
219 {
220         struct sk_security_struct *sksec = sk->sk_security;
221         struct netlbl_lsm_secattr secattr;
222         u32 nlbl_peer_sid;
223
224         rcu_read_lock();
225
226         if (sksec->nlbl_state != NLBL_REQUIRE) {
227                 rcu_read_unlock();
228                 return;
229         }
230
231         netlbl_secattr_init(&secattr);
232         if (netlbl_sock_getattr(sk, &secattr) == 0 &&
233             secattr.flags != NETLBL_SECATTR_NONE &&
234             security_netlbl_secattr_to_sid(&secattr, &nlbl_peer_sid) == 0)
235                 sksec->peer_sid = nlbl_peer_sid;
236         netlbl_secattr_destroy(&secattr);
237
238         /* Try to set the NetLabel on the socket to save time later, if we fail
239          * here we will pick up the pieces in later calls to
240          * selinux_netlbl_inode_permission(). */
241         selinux_netlbl_sock_setsid(sk, sksec->sid);
242
243         rcu_read_unlock();
244 }
245
246 /**
247  * selinux_netlbl_socket_post_create - Label a socket using NetLabel
248  * @sock: the socket to label
249  *
250  * Description:
251  * Attempt to label a socket using the NetLabel mechanism using the given
252  * SID.  Returns zero values on success, negative values on failure.
253  *
254  */
255 int selinux_netlbl_socket_post_create(struct socket *sock)
256 {
257         int rc = 0;
258         struct sock *sk = sock->sk;
259         struct sk_security_struct *sksec = sk->sk_security;
260
261         rcu_read_lock();
262         if (sksec->nlbl_state == NLBL_REQUIRE)
263                 rc = selinux_netlbl_sock_setsid(sk, sksec->sid);
264         rcu_read_unlock();
265
266         return rc;
267 }
268
269 /**
270  * selinux_netlbl_inode_permission - Verify the socket is NetLabel labeled
271  * @inode: the file descriptor's inode
272  * @mask: the permission mask
273  *
274  * Description:
275  * Looks at a file's inode and if it is marked as a socket protected by
276  * NetLabel then verify that the socket has been labeled, if not try to label
277  * the socket now with the inode's SID.  Returns zero on success, negative
278  * values on failure.
279  *
280  */
281 int selinux_netlbl_inode_permission(struct inode *inode, int mask)
282 {
283         int rc;
284         struct sock *sk;
285         struct socket *sock;
286         struct sk_security_struct *sksec;
287
288         if (!S_ISSOCK(inode->i_mode) ||
289             ((mask & (MAY_WRITE | MAY_APPEND)) == 0))
290                 return 0;
291         sock = SOCKET_I(inode);
292         sk = sock->sk;
293         sksec = sk->sk_security;
294
295         rcu_read_lock();
296         if (sksec->nlbl_state != NLBL_REQUIRE) {
297                 rcu_read_unlock();
298                 return 0;
299         }
300         local_bh_disable();
301         bh_lock_sock_nested(sk);
302         rc = selinux_netlbl_sock_setsid(sk, sksec->sid);
303         bh_unlock_sock(sk);
304         local_bh_enable();
305         rcu_read_unlock();
306
307         return rc;
308 }
309
310 /**
311  * selinux_netlbl_sock_rcv_skb - Do an inbound access check using NetLabel
312  * @sksec: the sock's sk_security_struct
313  * @skb: the packet
314  * @family: protocol family
315  * @ad: the audit data
316  *
317  * Description:
318  * Fetch the NetLabel security attributes from @skb and perform an access check
319  * against the receiving socket.  Returns zero on success, negative values on
320  * error.
321  *
322  */
323 int selinux_netlbl_sock_rcv_skb(struct sk_security_struct *sksec,
324                                 struct sk_buff *skb,
325                                 u16 family,
326                                 struct avc_audit_data *ad)
327 {
328         int rc;
329         u32 nlbl_sid;
330         u32 perm;
331         struct netlbl_lsm_secattr secattr;
332
333         if (!netlbl_enabled())
334                 return 0;
335
336         netlbl_secattr_init(&secattr);
337         rc = netlbl_skbuff_getattr(skb, family, &secattr);
338         if (rc == 0 && secattr.flags != NETLBL_SECATTR_NONE)
339                 rc = selinux_netlbl_sidlookup_cached(skb, &secattr, &nlbl_sid);
340         else
341                 nlbl_sid = SECINITSID_UNLABELED;
342         netlbl_secattr_destroy(&secattr);
343         if (rc != 0)
344                 return rc;
345
346         switch (sksec->sclass) {
347         case SECCLASS_UDP_SOCKET:
348                 perm = UDP_SOCKET__RECVFROM;
349                 break;
350         case SECCLASS_TCP_SOCKET:
351                 perm = TCP_SOCKET__RECVFROM;
352                 break;
353         default:
354                 perm = RAWIP_SOCKET__RECVFROM;
355         }
356
357         rc = avc_has_perm(sksec->sid, nlbl_sid, sksec->sclass, perm, ad);
358         if (rc == 0)
359                 return 0;
360
361         if (nlbl_sid != SECINITSID_UNLABELED)
362                 netlbl_skbuff_err(skb, rc);
363         return rc;
364 }
365
366 /**
367  * selinux_netlbl_socket_setsockopt - Do not allow users to remove a NetLabel
368  * @sock: the socket
369  * @level: the socket level or protocol
370  * @optname: the socket option name
371  *
372  * Description:
373  * Check the setsockopt() call and if the user is trying to replace the IP
374  * options on a socket and a NetLabel is in place for the socket deny the
375  * access; otherwise allow the access.  Returns zero when the access is
376  * allowed, -EACCES when denied, and other negative values on error.
377  *
378  */
379 int selinux_netlbl_socket_setsockopt(struct socket *sock,
380                                      int level,
381                                      int optname)
382 {
383         int rc = 0;
384         struct sock *sk = sock->sk;
385         struct sk_security_struct *sksec = sk->sk_security;
386         struct netlbl_lsm_secattr secattr;
387
388         rcu_read_lock();
389         if (level == IPPROTO_IP && optname == IP_OPTIONS &&
390             sksec->nlbl_state == NLBL_LABELED) {
391                 netlbl_secattr_init(&secattr);
392                 lock_sock(sk);
393                 rc = netlbl_sock_getattr(sk, &secattr);
394                 release_sock(sk);
395                 if (rc == 0 && secattr.flags != NETLBL_SECATTR_NONE)
396                         rc = -EACCES;
397                 netlbl_secattr_destroy(&secattr);
398         }
399         rcu_read_unlock();
400
401         return rc;
402 }