Linux 5.9-rc7
[sfrench/cifs-2.6.git] / security / selinux / xfrm.c
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  *  NSA Security-Enhanced Linux (SELinux) security module
4  *
5  *  This file contains the SELinux XFRM hook function implementations.
6  *
7  *  Authors:  Serge Hallyn <sergeh@us.ibm.com>
8  *            Trent Jaeger <jaegert@us.ibm.com>
9  *
10  *  Updated: Venkat Yekkirala <vyekkirala@TrustedCS.com>
11  *
12  *           Granular IPSec Associations for use in MLS environments.
13  *
14  *  Copyright (C) 2005 International Business Machines Corporation
15  *  Copyright (C) 2006 Trusted Computer Solutions, Inc.
16  */
17
18 /*
19  * USAGE:
20  * NOTES:
21  *   1. Make sure to enable the following options in your kernel config:
22  *      CONFIG_SECURITY=y
23  *      CONFIG_SECURITY_NETWORK=y
24  *      CONFIG_SECURITY_NETWORK_XFRM=y
25  *      CONFIG_SECURITY_SELINUX=m/y
26  * ISSUES:
27  *   1. Caching packets, so they are not dropped during negotiation
28  *   2. Emulating a reasonable SO_PEERSEC across machines
29  *   3. Testing addition of sk_policy's with security context via setsockopt
30  */
31 #include <linux/kernel.h>
32 #include <linux/init.h>
33 #include <linux/security.h>
34 #include <linux/types.h>
35 #include <linux/slab.h>
36 #include <linux/ip.h>
37 #include <linux/tcp.h>
38 #include <linux/skbuff.h>
39 #include <linux/xfrm.h>
40 #include <net/xfrm.h>
41 #include <net/checksum.h>
42 #include <net/udp.h>
43 #include <linux/atomic.h>
44
45 #include "avc.h"
46 #include "objsec.h"
47 #include "xfrm.h"
48
49 /* Labeled XFRM instance counter */
50 atomic_t selinux_xfrm_refcount = ATOMIC_INIT(0);
51
52 /*
53  * Returns true if the context is an LSM/SELinux context.
54  */
55 static inline int selinux_authorizable_ctx(struct xfrm_sec_ctx *ctx)
56 {
57         return (ctx &&
58                 (ctx->ctx_doi == XFRM_SC_DOI_LSM) &&
59                 (ctx->ctx_alg == XFRM_SC_ALG_SELINUX));
60 }
61
62 /*
63  * Returns true if the xfrm contains a security blob for SELinux.
64  */
65 static inline int selinux_authorizable_xfrm(struct xfrm_state *x)
66 {
67         return selinux_authorizable_ctx(x->security);
68 }
69
70 /*
71  * Allocates a xfrm_sec_state and populates it using the supplied security
72  * xfrm_user_sec_ctx context.
73  */
74 static int selinux_xfrm_alloc_user(struct xfrm_sec_ctx **ctxp,
75                                    struct xfrm_user_sec_ctx *uctx,
76                                    gfp_t gfp)
77 {
78         int rc;
79         const struct task_security_struct *tsec = selinux_cred(current_cred());
80         struct xfrm_sec_ctx *ctx = NULL;
81         u32 str_len;
82
83         if (ctxp == NULL || uctx == NULL ||
84             uctx->ctx_doi != XFRM_SC_DOI_LSM ||
85             uctx->ctx_alg != XFRM_SC_ALG_SELINUX)
86                 return -EINVAL;
87
88         str_len = uctx->ctx_len;
89         if (str_len >= PAGE_SIZE)
90                 return -ENOMEM;
91
92         ctx = kmalloc(sizeof(*ctx) + str_len + 1, gfp);
93         if (!ctx)
94                 return -ENOMEM;
95
96         ctx->ctx_doi = XFRM_SC_DOI_LSM;
97         ctx->ctx_alg = XFRM_SC_ALG_SELINUX;
98         ctx->ctx_len = str_len;
99         memcpy(ctx->ctx_str, &uctx[1], str_len);
100         ctx->ctx_str[str_len] = '\0';
101         rc = security_context_to_sid(&selinux_state, ctx->ctx_str, str_len,
102                                      &ctx->ctx_sid, gfp);
103         if (rc)
104                 goto err;
105
106         rc = avc_has_perm(&selinux_state,
107                           tsec->sid, ctx->ctx_sid,
108                           SECCLASS_ASSOCIATION, ASSOCIATION__SETCONTEXT, NULL);
109         if (rc)
110                 goto err;
111
112         *ctxp = ctx;
113         atomic_inc(&selinux_xfrm_refcount);
114         return 0;
115
116 err:
117         kfree(ctx);
118         return rc;
119 }
120
121 /*
122  * Free the xfrm_sec_ctx structure.
123  */
124 static void selinux_xfrm_free(struct xfrm_sec_ctx *ctx)
125 {
126         if (!ctx)
127                 return;
128
129         atomic_dec(&selinux_xfrm_refcount);
130         kfree(ctx);
131 }
132
133 /*
134  * Authorize the deletion of a labeled SA or policy rule.
135  */
136 static int selinux_xfrm_delete(struct xfrm_sec_ctx *ctx)
137 {
138         const struct task_security_struct *tsec = selinux_cred(current_cred());
139
140         if (!ctx)
141                 return 0;
142
143         return avc_has_perm(&selinux_state,
144                             tsec->sid, ctx->ctx_sid,
145                             SECCLASS_ASSOCIATION, ASSOCIATION__SETCONTEXT,
146                             NULL);
147 }
148
149 /*
150  * LSM hook implementation that authorizes that a flow can use a xfrm policy
151  * rule.
152  */
153 int selinux_xfrm_policy_lookup(struct xfrm_sec_ctx *ctx, u32 fl_secid, u8 dir)
154 {
155         int rc;
156
157         /* All flows should be treated as polmatch'ing an otherwise applicable
158          * "non-labeled" policy. This would prevent inadvertent "leaks". */
159         if (!ctx)
160                 return 0;
161
162         /* Context sid is either set to label or ANY_ASSOC */
163         if (!selinux_authorizable_ctx(ctx))
164                 return -EINVAL;
165
166         rc = avc_has_perm(&selinux_state,
167                           fl_secid, ctx->ctx_sid,
168                           SECCLASS_ASSOCIATION, ASSOCIATION__POLMATCH, NULL);
169         return (rc == -EACCES ? -ESRCH : rc);
170 }
171
172 /*
173  * LSM hook implementation that authorizes that a state matches
174  * the given policy, flow combo.
175  */
176 int selinux_xfrm_state_pol_flow_match(struct xfrm_state *x,
177                                       struct xfrm_policy *xp,
178                                       const struct flowi *fl)
179 {
180         u32 state_sid;
181
182         if (!xp->security)
183                 if (x->security)
184                         /* unlabeled policy and labeled SA can't match */
185                         return 0;
186                 else
187                         /* unlabeled policy and unlabeled SA match all flows */
188                         return 1;
189         else
190                 if (!x->security)
191                         /* unlabeled SA and labeled policy can't match */
192                         return 0;
193                 else
194                         if (!selinux_authorizable_xfrm(x))
195                                 /* Not a SELinux-labeled SA */
196                                 return 0;
197
198         state_sid = x->security->ctx_sid;
199
200         if (fl->flowi_secid != state_sid)
201                 return 0;
202
203         /* We don't need a separate SA Vs. policy polmatch check since the SA
204          * is now of the same label as the flow and a flow Vs. policy polmatch
205          * check had already happened in selinux_xfrm_policy_lookup() above. */
206         return (avc_has_perm(&selinux_state,
207                              fl->flowi_secid, state_sid,
208                             SECCLASS_ASSOCIATION, ASSOCIATION__SENDTO,
209                             NULL) ? 0 : 1);
210 }
211
212 static u32 selinux_xfrm_skb_sid_egress(struct sk_buff *skb)
213 {
214         struct dst_entry *dst = skb_dst(skb);
215         struct xfrm_state *x;
216
217         if (dst == NULL)
218                 return SECSID_NULL;
219         x = dst->xfrm;
220         if (x == NULL || !selinux_authorizable_xfrm(x))
221                 return SECSID_NULL;
222
223         return x->security->ctx_sid;
224 }
225
226 static int selinux_xfrm_skb_sid_ingress(struct sk_buff *skb,
227                                         u32 *sid, int ckall)
228 {
229         u32 sid_session = SECSID_NULL;
230         struct sec_path *sp = skb_sec_path(skb);
231
232         if (sp) {
233                 int i;
234
235                 for (i = sp->len - 1; i >= 0; i--) {
236                         struct xfrm_state *x = sp->xvec[i];
237                         if (selinux_authorizable_xfrm(x)) {
238                                 struct xfrm_sec_ctx *ctx = x->security;
239
240                                 if (sid_session == SECSID_NULL) {
241                                         sid_session = ctx->ctx_sid;
242                                         if (!ckall)
243                                                 goto out;
244                                 } else if (sid_session != ctx->ctx_sid) {
245                                         *sid = SECSID_NULL;
246                                         return -EINVAL;
247                                 }
248                         }
249                 }
250         }
251
252 out:
253         *sid = sid_session;
254         return 0;
255 }
256
257 /*
258  * LSM hook implementation that checks and/or returns the xfrm sid for the
259  * incoming packet.
260  */
261 int selinux_xfrm_decode_session(struct sk_buff *skb, u32 *sid, int ckall)
262 {
263         if (skb == NULL) {
264                 *sid = SECSID_NULL;
265                 return 0;
266         }
267         return selinux_xfrm_skb_sid_ingress(skb, sid, ckall);
268 }
269
270 int selinux_xfrm_skb_sid(struct sk_buff *skb, u32 *sid)
271 {
272         int rc;
273
274         rc = selinux_xfrm_skb_sid_ingress(skb, sid, 0);
275         if (rc == 0 && *sid == SECSID_NULL)
276                 *sid = selinux_xfrm_skb_sid_egress(skb);
277
278         return rc;
279 }
280
281 /*
282  * LSM hook implementation that allocs and transfers uctx spec to xfrm_policy.
283  */
284 int selinux_xfrm_policy_alloc(struct xfrm_sec_ctx **ctxp,
285                               struct xfrm_user_sec_ctx *uctx,
286                               gfp_t gfp)
287 {
288         return selinux_xfrm_alloc_user(ctxp, uctx, gfp);
289 }
290
291 /*
292  * LSM hook implementation that copies security data structure from old to new
293  * for policy cloning.
294  */
295 int selinux_xfrm_policy_clone(struct xfrm_sec_ctx *old_ctx,
296                               struct xfrm_sec_ctx **new_ctxp)
297 {
298         struct xfrm_sec_ctx *new_ctx;
299
300         if (!old_ctx)
301                 return 0;
302
303         new_ctx = kmemdup(old_ctx, sizeof(*old_ctx) + old_ctx->ctx_len,
304                           GFP_ATOMIC);
305         if (!new_ctx)
306                 return -ENOMEM;
307         atomic_inc(&selinux_xfrm_refcount);
308         *new_ctxp = new_ctx;
309
310         return 0;
311 }
312
313 /*
314  * LSM hook implementation that frees xfrm_sec_ctx security information.
315  */
316 void selinux_xfrm_policy_free(struct xfrm_sec_ctx *ctx)
317 {
318         selinux_xfrm_free(ctx);
319 }
320
321 /*
322  * LSM hook implementation that authorizes deletion of labeled policies.
323  */
324 int selinux_xfrm_policy_delete(struct xfrm_sec_ctx *ctx)
325 {
326         return selinux_xfrm_delete(ctx);
327 }
328
329 /*
330  * LSM hook implementation that allocates a xfrm_sec_state, populates it using
331  * the supplied security context, and assigns it to the xfrm_state.
332  */
333 int selinux_xfrm_state_alloc(struct xfrm_state *x,
334                              struct xfrm_user_sec_ctx *uctx)
335 {
336         return selinux_xfrm_alloc_user(&x->security, uctx, GFP_KERNEL);
337 }
338
339 /*
340  * LSM hook implementation that allocates a xfrm_sec_state and populates based
341  * on a secid.
342  */
343 int selinux_xfrm_state_alloc_acquire(struct xfrm_state *x,
344                                      struct xfrm_sec_ctx *polsec, u32 secid)
345 {
346         int rc;
347         struct xfrm_sec_ctx *ctx;
348         char *ctx_str = NULL;
349         int str_len;
350
351         if (!polsec)
352                 return 0;
353
354         if (secid == 0)
355                 return -EINVAL;
356
357         rc = security_sid_to_context(&selinux_state, secid, &ctx_str,
358                                      &str_len);
359         if (rc)
360                 return rc;
361
362         ctx = kmalloc(sizeof(*ctx) + str_len, GFP_ATOMIC);
363         if (!ctx) {
364                 rc = -ENOMEM;
365                 goto out;
366         }
367
368         ctx->ctx_doi = XFRM_SC_DOI_LSM;
369         ctx->ctx_alg = XFRM_SC_ALG_SELINUX;
370         ctx->ctx_sid = secid;
371         ctx->ctx_len = str_len;
372         memcpy(ctx->ctx_str, ctx_str, str_len);
373
374         x->security = ctx;
375         atomic_inc(&selinux_xfrm_refcount);
376 out:
377         kfree(ctx_str);
378         return rc;
379 }
380
381 /*
382  * LSM hook implementation that frees xfrm_state security information.
383  */
384 void selinux_xfrm_state_free(struct xfrm_state *x)
385 {
386         selinux_xfrm_free(x->security);
387 }
388
389 /*
390  * LSM hook implementation that authorizes deletion of labeled SAs.
391  */
392 int selinux_xfrm_state_delete(struct xfrm_state *x)
393 {
394         return selinux_xfrm_delete(x->security);
395 }
396
397 /*
398  * LSM hook that controls access to unlabelled packets.  If
399  * a xfrm_state is authorizable (defined by macro) then it was
400  * already authorized by the IPSec process.  If not, then
401  * we need to check for unlabelled access since this may not have
402  * gone thru the IPSec process.
403  */
404 int selinux_xfrm_sock_rcv_skb(u32 sk_sid, struct sk_buff *skb,
405                               struct common_audit_data *ad)
406 {
407         int i;
408         struct sec_path *sp = skb_sec_path(skb);
409         u32 peer_sid = SECINITSID_UNLABELED;
410
411         if (sp) {
412                 for (i = 0; i < sp->len; i++) {
413                         struct xfrm_state *x = sp->xvec[i];
414
415                         if (x && selinux_authorizable_xfrm(x)) {
416                                 struct xfrm_sec_ctx *ctx = x->security;
417                                 peer_sid = ctx->ctx_sid;
418                                 break;
419                         }
420                 }
421         }
422
423         /* This check even when there's no association involved is intended,
424          * according to Trent Jaeger, to make sure a process can't engage in
425          * non-IPsec communication unless explicitly allowed by policy. */
426         return avc_has_perm(&selinux_state,
427                             sk_sid, peer_sid,
428                             SECCLASS_ASSOCIATION, ASSOCIATION__RECVFROM, ad);
429 }
430
431 /*
432  * POSTROUTE_LAST hook's XFRM processing:
433  * If we have no security association, then we need to determine
434  * whether the socket is allowed to send to an unlabelled destination.
435  * If we do have a authorizable security association, then it has already been
436  * checked in the selinux_xfrm_state_pol_flow_match hook above.
437  */
438 int selinux_xfrm_postroute_last(u32 sk_sid, struct sk_buff *skb,
439                                 struct common_audit_data *ad, u8 proto)
440 {
441         struct dst_entry *dst;
442
443         switch (proto) {
444         case IPPROTO_AH:
445         case IPPROTO_ESP:
446         case IPPROTO_COMP:
447                 /* We should have already seen this packet once before it
448                  * underwent xfrm(s). No need to subject it to the unlabeled
449                  * check. */
450                 return 0;
451         default:
452                 break;
453         }
454
455         dst = skb_dst(skb);
456         if (dst) {
457                 struct dst_entry *iter;
458
459                 for (iter = dst; iter != NULL; iter = xfrm_dst_child(iter)) {
460                         struct xfrm_state *x = iter->xfrm;
461
462                         if (x && selinux_authorizable_xfrm(x))
463                                 return 0;
464                 }
465         }
466
467         /* This check even when there's no association involved is intended,
468          * according to Trent Jaeger, to make sure a process can't engage in
469          * non-IPsec communication unless explicitly allowed by policy. */
470         return avc_has_perm(&selinux_state, sk_sid, SECINITSID_UNLABELED,
471                             SECCLASS_ASSOCIATION, ASSOCIATION__SENDTO, ad);
472 }