Loading...
1/*
2 * Implementation of the SID table type.
3 *
4 * Author : Stephen Smalley, <sds@epoch.ncsc.mil>
5 */
6#include <linux/kernel.h>
7#include <linux/slab.h>
8#include <linux/spinlock.h>
9#include <linux/errno.h>
10#include "flask.h"
11#include "security.h"
12#include "sidtab.h"
13
14#define SIDTAB_HASH(sid) \
15(sid & SIDTAB_HASH_MASK)
16
17int sidtab_init(struct sidtab *s)
18{
19 int i;
20
21 s->htable = kmalloc(sizeof(*(s->htable)) * SIDTAB_SIZE, GFP_ATOMIC);
22 if (!s->htable)
23 return -ENOMEM;
24 for (i = 0; i < SIDTAB_SIZE; i++)
25 s->htable[i] = NULL;
26 s->nel = 0;
27 s->next_sid = 1;
28 s->shutdown = 0;
29 spin_lock_init(&s->lock);
30 return 0;
31}
32
33int sidtab_insert(struct sidtab *s, u32 sid, struct context *context)
34{
35 int hvalue, rc = 0;
36 struct sidtab_node *prev, *cur, *newnode;
37
38 if (!s) {
39 rc = -ENOMEM;
40 goto out;
41 }
42
43 hvalue = SIDTAB_HASH(sid);
44 prev = NULL;
45 cur = s->htable[hvalue];
46 while (cur && sid > cur->sid) {
47 prev = cur;
48 cur = cur->next;
49 }
50
51 if (cur && sid == cur->sid) {
52 rc = -EEXIST;
53 goto out;
54 }
55
56 newnode = kmalloc(sizeof(*newnode), GFP_ATOMIC);
57 if (newnode == NULL) {
58 rc = -ENOMEM;
59 goto out;
60 }
61 newnode->sid = sid;
62 if (context_cpy(&newnode->context, context)) {
63 kfree(newnode);
64 rc = -ENOMEM;
65 goto out;
66 }
67
68 if (prev) {
69 newnode->next = prev->next;
70 wmb();
71 prev->next = newnode;
72 } else {
73 newnode->next = s->htable[hvalue];
74 wmb();
75 s->htable[hvalue] = newnode;
76 }
77
78 s->nel++;
79 if (sid >= s->next_sid)
80 s->next_sid = sid + 1;
81out:
82 return rc;
83}
84
85static struct context *sidtab_search_core(struct sidtab *s, u32 sid, int force)
86{
87 int hvalue;
88 struct sidtab_node *cur;
89
90 if (!s)
91 return NULL;
92
93 hvalue = SIDTAB_HASH(sid);
94 cur = s->htable[hvalue];
95 while (cur && sid > cur->sid)
96 cur = cur->next;
97
98 if (force && cur && sid == cur->sid && cur->context.len)
99 return &cur->context;
100
101 if (cur == NULL || sid != cur->sid || cur->context.len) {
102 /* Remap invalid SIDs to the unlabeled SID. */
103 sid = SECINITSID_UNLABELED;
104 hvalue = SIDTAB_HASH(sid);
105 cur = s->htable[hvalue];
106 while (cur && sid > cur->sid)
107 cur = cur->next;
108 if (!cur || sid != cur->sid)
109 return NULL;
110 }
111
112 return &cur->context;
113}
114
115struct context *sidtab_search(struct sidtab *s, u32 sid)
116{
117 return sidtab_search_core(s, sid, 0);
118}
119
120struct context *sidtab_search_force(struct sidtab *s, u32 sid)
121{
122 return sidtab_search_core(s, sid, 1);
123}
124
125int sidtab_map(struct sidtab *s,
126 int (*apply) (u32 sid,
127 struct context *context,
128 void *args),
129 void *args)
130{
131 int i, rc = 0;
132 struct sidtab_node *cur;
133
134 if (!s)
135 goto out;
136
137 for (i = 0; i < SIDTAB_SIZE; i++) {
138 cur = s->htable[i];
139 while (cur) {
140 rc = apply(cur->sid, &cur->context, args);
141 if (rc)
142 goto out;
143 cur = cur->next;
144 }
145 }
146out:
147 return rc;
148}
149
150static void sidtab_update_cache(struct sidtab *s, struct sidtab_node *n, int loc)
151{
152 BUG_ON(loc >= SIDTAB_CACHE_LEN);
153
154 while (loc > 0) {
155 s->cache[loc] = s->cache[loc - 1];
156 loc--;
157 }
158 s->cache[0] = n;
159}
160
161static inline u32 sidtab_search_context(struct sidtab *s,
162 struct context *context)
163{
164 int i;
165 struct sidtab_node *cur;
166
167 for (i = 0; i < SIDTAB_SIZE; i++) {
168 cur = s->htable[i];
169 while (cur) {
170 if (context_cmp(&cur->context, context)) {
171 sidtab_update_cache(s, cur, SIDTAB_CACHE_LEN - 1);
172 return cur->sid;
173 }
174 cur = cur->next;
175 }
176 }
177 return 0;
178}
179
180static inline u32 sidtab_search_cache(struct sidtab *s, struct context *context)
181{
182 int i;
183 struct sidtab_node *node;
184
185 for (i = 0; i < SIDTAB_CACHE_LEN; i++) {
186 node = s->cache[i];
187 if (unlikely(!node))
188 return 0;
189 if (context_cmp(&node->context, context)) {
190 sidtab_update_cache(s, node, i);
191 return node->sid;
192 }
193 }
194 return 0;
195}
196
197int sidtab_context_to_sid(struct sidtab *s,
198 struct context *context,
199 u32 *out_sid)
200{
201 u32 sid;
202 int ret = 0;
203 unsigned long flags;
204
205 *out_sid = SECSID_NULL;
206
207 sid = sidtab_search_cache(s, context);
208 if (!sid)
209 sid = sidtab_search_context(s, context);
210 if (!sid) {
211 spin_lock_irqsave(&s->lock, flags);
212 /* Rescan now that we hold the lock. */
213 sid = sidtab_search_context(s, context);
214 if (sid)
215 goto unlock_out;
216 /* No SID exists for the context. Allocate a new one. */
217 if (s->next_sid == UINT_MAX || s->shutdown) {
218 ret = -ENOMEM;
219 goto unlock_out;
220 }
221 sid = s->next_sid++;
222 if (context->len)
223 printk(KERN_INFO
224 "SELinux: Context %s is not valid (left unmapped).\n",
225 context->str);
226 ret = sidtab_insert(s, sid, context);
227 if (ret)
228 s->next_sid--;
229unlock_out:
230 spin_unlock_irqrestore(&s->lock, flags);
231 }
232
233 if (ret)
234 return ret;
235
236 *out_sid = sid;
237 return 0;
238}
239
240void sidtab_hash_eval(struct sidtab *h, char *tag)
241{
242 int i, chain_len, slots_used, max_chain_len;
243 struct sidtab_node *cur;
244
245 slots_used = 0;
246 max_chain_len = 0;
247 for (i = 0; i < SIDTAB_SIZE; i++) {
248 cur = h->htable[i];
249 if (cur) {
250 slots_used++;
251 chain_len = 0;
252 while (cur) {
253 chain_len++;
254 cur = cur->next;
255 }
256
257 if (chain_len > max_chain_len)
258 max_chain_len = chain_len;
259 }
260 }
261
262 printk(KERN_DEBUG "%s: %d entries and %d/%d buckets used, longest "
263 "chain length %d\n", tag, h->nel, slots_used, SIDTAB_SIZE,
264 max_chain_len);
265}
266
267void sidtab_destroy(struct sidtab *s)
268{
269 int i;
270 struct sidtab_node *cur, *temp;
271
272 if (!s)
273 return;
274
275 for (i = 0; i < SIDTAB_SIZE; i++) {
276 cur = s->htable[i];
277 while (cur) {
278 temp = cur;
279 cur = cur->next;
280 context_destroy(&temp->context);
281 kfree(temp);
282 }
283 s->htable[i] = NULL;
284 }
285 kfree(s->htable);
286 s->htable = NULL;
287 s->nel = 0;
288 s->next_sid = 1;
289}
290
291void sidtab_set(struct sidtab *dst, struct sidtab *src)
292{
293 unsigned long flags;
294 int i;
295
296 spin_lock_irqsave(&src->lock, flags);
297 dst->htable = src->htable;
298 dst->nel = src->nel;
299 dst->next_sid = src->next_sid;
300 dst->shutdown = 0;
301 for (i = 0; i < SIDTAB_CACHE_LEN; i++)
302 dst->cache[i] = NULL;
303 spin_unlock_irqrestore(&src->lock, flags);
304}
305
306void sidtab_shutdown(struct sidtab *s)
307{
308 unsigned long flags;
309
310 spin_lock_irqsave(&s->lock, flags);
311 s->shutdown = 1;
312 spin_unlock_irqrestore(&s->lock, flags);
313}
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Implementation of the SID table type.
4 *
5 * Original author: Stephen Smalley, <sds@tycho.nsa.gov>
6 * Author: Ondrej Mosnacek, <omosnacek@gmail.com>
7 *
8 * Copyright (C) 2018 Red Hat, Inc.
9 */
10#include <linux/errno.h>
11#include <linux/kernel.h>
12#include <linux/slab.h>
13#include <linux/sched.h>
14#include <linux/spinlock.h>
15#include <asm/barrier.h>
16#include "flask.h"
17#include "security.h"
18#include "sidtab.h"
19
20int sidtab_init(struct sidtab *s)
21{
22 u32 i;
23
24 memset(s->roots, 0, sizeof(s->roots));
25
26 /* max count is SIDTAB_MAX so valid index is always < SIDTAB_MAX */
27 for (i = 0; i < SIDTAB_RCACHE_SIZE; i++)
28 s->rcache[i] = SIDTAB_MAX;
29
30 for (i = 0; i < SECINITSID_NUM; i++)
31 s->isids[i].set = 0;
32
33 s->count = 0;
34 s->convert = NULL;
35
36 spin_lock_init(&s->lock);
37 return 0;
38}
39
40int sidtab_set_initial(struct sidtab *s, u32 sid, struct context *context)
41{
42 struct sidtab_isid_entry *entry;
43 int rc;
44
45 if (sid == 0 || sid > SECINITSID_NUM)
46 return -EINVAL;
47
48 entry = &s->isids[sid - 1];
49
50 rc = context_cpy(&entry->context, context);
51 if (rc)
52 return rc;
53
54 entry->set = 1;
55 return 0;
56}
57
58static u32 sidtab_level_from_count(u32 count)
59{
60 u32 capacity = SIDTAB_LEAF_ENTRIES;
61 u32 level = 0;
62
63 while (count > capacity) {
64 capacity <<= SIDTAB_INNER_SHIFT;
65 ++level;
66 }
67 return level;
68}
69
70static int sidtab_alloc_roots(struct sidtab *s, u32 level)
71{
72 u32 l;
73
74 if (!s->roots[0].ptr_leaf) {
75 s->roots[0].ptr_leaf = kzalloc(SIDTAB_NODE_ALLOC_SIZE,
76 GFP_ATOMIC);
77 if (!s->roots[0].ptr_leaf)
78 return -ENOMEM;
79 }
80 for (l = 1; l <= level; ++l)
81 if (!s->roots[l].ptr_inner) {
82 s->roots[l].ptr_inner = kzalloc(SIDTAB_NODE_ALLOC_SIZE,
83 GFP_ATOMIC);
84 if (!s->roots[l].ptr_inner)
85 return -ENOMEM;
86 s->roots[l].ptr_inner->entries[0] = s->roots[l - 1];
87 }
88 return 0;
89}
90
91static struct context *sidtab_do_lookup(struct sidtab *s, u32 index, int alloc)
92{
93 union sidtab_entry_inner *entry;
94 u32 level, capacity_shift, leaf_index = index / SIDTAB_LEAF_ENTRIES;
95
96 /* find the level of the subtree we need */
97 level = sidtab_level_from_count(index + 1);
98 capacity_shift = level * SIDTAB_INNER_SHIFT;
99
100 /* allocate roots if needed */
101 if (alloc && sidtab_alloc_roots(s, level) != 0)
102 return NULL;
103
104 /* lookup inside the subtree */
105 entry = &s->roots[level];
106 while (level != 0) {
107 capacity_shift -= SIDTAB_INNER_SHIFT;
108 --level;
109
110 entry = &entry->ptr_inner->entries[leaf_index >> capacity_shift];
111 leaf_index &= ((u32)1 << capacity_shift) - 1;
112
113 if (!entry->ptr_inner) {
114 if (alloc)
115 entry->ptr_inner = kzalloc(SIDTAB_NODE_ALLOC_SIZE,
116 GFP_ATOMIC);
117 if (!entry->ptr_inner)
118 return NULL;
119 }
120 }
121 if (!entry->ptr_leaf) {
122 if (alloc)
123 entry->ptr_leaf = kzalloc(SIDTAB_NODE_ALLOC_SIZE,
124 GFP_ATOMIC);
125 if (!entry->ptr_leaf)
126 return NULL;
127 }
128 return &entry->ptr_leaf->entries[index % SIDTAB_LEAF_ENTRIES].context;
129}
130
131static struct context *sidtab_lookup(struct sidtab *s, u32 index)
132{
133 /* read entries only after reading count */
134 u32 count = smp_load_acquire(&s->count);
135
136 if (index >= count)
137 return NULL;
138
139 return sidtab_do_lookup(s, index, 0);
140}
141
142static struct context *sidtab_lookup_initial(struct sidtab *s, u32 sid)
143{
144 return s->isids[sid - 1].set ? &s->isids[sid - 1].context : NULL;
145}
146
147static struct context *sidtab_search_core(struct sidtab *s, u32 sid, int force)
148{
149 struct context *context;
150
151 if (sid != 0) {
152 if (sid > SECINITSID_NUM)
153 context = sidtab_lookup(s, sid - (SECINITSID_NUM + 1));
154 else
155 context = sidtab_lookup_initial(s, sid);
156 if (context && (!context->len || force))
157 return context;
158 }
159
160 return sidtab_lookup_initial(s, SECINITSID_UNLABELED);
161}
162
163struct context *sidtab_search(struct sidtab *s, u32 sid)
164{
165 return sidtab_search_core(s, sid, 0);
166}
167
168struct context *sidtab_search_force(struct sidtab *s, u32 sid)
169{
170 return sidtab_search_core(s, sid, 1);
171}
172
173static int sidtab_find_context(union sidtab_entry_inner entry,
174 u32 *pos, u32 count, u32 level,
175 struct context *context, u32 *index)
176{
177 int rc;
178 u32 i;
179
180 if (level != 0) {
181 struct sidtab_node_inner *node = entry.ptr_inner;
182
183 i = 0;
184 while (i < SIDTAB_INNER_ENTRIES && *pos < count) {
185 rc = sidtab_find_context(node->entries[i],
186 pos, count, level - 1,
187 context, index);
188 if (rc == 0)
189 return 0;
190 i++;
191 }
192 } else {
193 struct sidtab_node_leaf *node = entry.ptr_leaf;
194
195 i = 0;
196 while (i < SIDTAB_LEAF_ENTRIES && *pos < count) {
197 if (context_cmp(&node->entries[i].context, context)) {
198 *index = *pos;
199 return 0;
200 }
201 (*pos)++;
202 i++;
203 }
204 }
205 return -ENOENT;
206}
207
208static void sidtab_rcache_update(struct sidtab *s, u32 index, u32 pos)
209{
210 while (pos > 0) {
211 WRITE_ONCE(s->rcache[pos], READ_ONCE(s->rcache[pos - 1]));
212 --pos;
213 }
214 WRITE_ONCE(s->rcache[0], index);
215}
216
217static void sidtab_rcache_push(struct sidtab *s, u32 index)
218{
219 sidtab_rcache_update(s, index, SIDTAB_RCACHE_SIZE - 1);
220}
221
222static int sidtab_rcache_search(struct sidtab *s, struct context *context,
223 u32 *index)
224{
225 u32 i;
226
227 for (i = 0; i < SIDTAB_RCACHE_SIZE; i++) {
228 u32 v = READ_ONCE(s->rcache[i]);
229
230 if (v >= SIDTAB_MAX)
231 continue;
232
233 if (context_cmp(sidtab_do_lookup(s, v, 0), context)) {
234 sidtab_rcache_update(s, v, i);
235 *index = v;
236 return 0;
237 }
238 }
239 return -ENOENT;
240}
241
242static int sidtab_reverse_lookup(struct sidtab *s, struct context *context,
243 u32 *index)
244{
245 unsigned long flags;
246 u32 count, count_locked, level, pos;
247 struct sidtab_convert_params *convert;
248 struct context *dst, *dst_convert;
249 int rc;
250
251 rc = sidtab_rcache_search(s, context, index);
252 if (rc == 0)
253 return 0;
254
255 /* read entries only after reading count */
256 count = smp_load_acquire(&s->count);
257 level = sidtab_level_from_count(count);
258
259 pos = 0;
260 rc = sidtab_find_context(s->roots[level], &pos, count, level,
261 context, index);
262 if (rc == 0) {
263 sidtab_rcache_push(s, *index);
264 return 0;
265 }
266
267 /* lock-free search failed: lock, re-search, and insert if not found */
268 spin_lock_irqsave(&s->lock, flags);
269
270 convert = s->convert;
271 count_locked = s->count;
272 level = sidtab_level_from_count(count_locked);
273
274 /* if count has changed before we acquired the lock, then catch up */
275 while (count < count_locked) {
276 if (context_cmp(sidtab_do_lookup(s, count, 0), context)) {
277 sidtab_rcache_push(s, count);
278 *index = count;
279 rc = 0;
280 goto out_unlock;
281 }
282 ++count;
283 }
284
285 /* bail out if we already reached max entries */
286 rc = -EOVERFLOW;
287 if (count >= SIDTAB_MAX)
288 goto out_unlock;
289
290 /* insert context into new entry */
291 rc = -ENOMEM;
292 dst = sidtab_do_lookup(s, count, 1);
293 if (!dst)
294 goto out_unlock;
295
296 rc = context_cpy(dst, context);
297 if (rc)
298 goto out_unlock;
299
300 /*
301 * if we are building a new sidtab, we need to convert the context
302 * and insert it there as well
303 */
304 if (convert) {
305 rc = -ENOMEM;
306 dst_convert = sidtab_do_lookup(convert->target, count, 1);
307 if (!dst_convert) {
308 context_destroy(dst);
309 goto out_unlock;
310 }
311
312 rc = convert->func(context, dst_convert, convert->args);
313 if (rc) {
314 context_destroy(dst);
315 goto out_unlock;
316 }
317
318 /* at this point we know the insert won't fail */
319 convert->target->count = count + 1;
320 }
321
322 if (context->len)
323 pr_info("SELinux: Context %s is not valid (left unmapped).\n",
324 context->str);
325
326 sidtab_rcache_push(s, count);
327 *index = count;
328
329 /* write entries before writing new count */
330 smp_store_release(&s->count, count + 1);
331
332 rc = 0;
333out_unlock:
334 spin_unlock_irqrestore(&s->lock, flags);
335 return rc;
336}
337
338int sidtab_context_to_sid(struct sidtab *s, struct context *context, u32 *sid)
339{
340 int rc;
341 u32 i;
342
343 for (i = 0; i < SECINITSID_NUM; i++) {
344 struct sidtab_isid_entry *entry = &s->isids[i];
345
346 if (entry->set && context_cmp(context, &entry->context)) {
347 *sid = i + 1;
348 return 0;
349 }
350 }
351
352 rc = sidtab_reverse_lookup(s, context, sid);
353 if (rc)
354 return rc;
355 *sid += SECINITSID_NUM + 1;
356 return 0;
357}
358
359static int sidtab_convert_tree(union sidtab_entry_inner *edst,
360 union sidtab_entry_inner *esrc,
361 u32 *pos, u32 count, u32 level,
362 struct sidtab_convert_params *convert)
363{
364 int rc;
365 u32 i;
366
367 if (level != 0) {
368 if (!edst->ptr_inner) {
369 edst->ptr_inner = kzalloc(SIDTAB_NODE_ALLOC_SIZE,
370 GFP_KERNEL);
371 if (!edst->ptr_inner)
372 return -ENOMEM;
373 }
374 i = 0;
375 while (i < SIDTAB_INNER_ENTRIES && *pos < count) {
376 rc = sidtab_convert_tree(&edst->ptr_inner->entries[i],
377 &esrc->ptr_inner->entries[i],
378 pos, count, level - 1,
379 convert);
380 if (rc)
381 return rc;
382 i++;
383 }
384 } else {
385 if (!edst->ptr_leaf) {
386 edst->ptr_leaf = kzalloc(SIDTAB_NODE_ALLOC_SIZE,
387 GFP_KERNEL);
388 if (!edst->ptr_leaf)
389 return -ENOMEM;
390 }
391 i = 0;
392 while (i < SIDTAB_LEAF_ENTRIES && *pos < count) {
393 rc = convert->func(&esrc->ptr_leaf->entries[i].context,
394 &edst->ptr_leaf->entries[i].context,
395 convert->args);
396 if (rc)
397 return rc;
398 (*pos)++;
399 i++;
400 }
401 cond_resched();
402 }
403 return 0;
404}
405
406int sidtab_convert(struct sidtab *s, struct sidtab_convert_params *params)
407{
408 unsigned long flags;
409 u32 count, level, pos;
410 int rc;
411
412 spin_lock_irqsave(&s->lock, flags);
413
414 /* concurrent policy loads are not allowed */
415 if (s->convert) {
416 spin_unlock_irqrestore(&s->lock, flags);
417 return -EBUSY;
418 }
419
420 count = s->count;
421 level = sidtab_level_from_count(count);
422
423 /* allocate last leaf in the new sidtab (to avoid race with
424 * live convert)
425 */
426 rc = sidtab_do_lookup(params->target, count - 1, 1) ? 0 : -ENOMEM;
427 if (rc) {
428 spin_unlock_irqrestore(&s->lock, flags);
429 return rc;
430 }
431
432 /* set count in case no new entries are added during conversion */
433 params->target->count = count;
434
435 /* enable live convert of new entries */
436 s->convert = params;
437
438 /* we can safely do the rest of the conversion outside the lock */
439 spin_unlock_irqrestore(&s->lock, flags);
440
441 pr_info("SELinux: Converting %u SID table entries...\n", count);
442
443 /* convert all entries not covered by live convert */
444 pos = 0;
445 rc = sidtab_convert_tree(¶ms->target->roots[level],
446 &s->roots[level], &pos, count, level, params);
447 if (rc) {
448 /* we need to keep the old table - disable live convert */
449 spin_lock_irqsave(&s->lock, flags);
450 s->convert = NULL;
451 spin_unlock_irqrestore(&s->lock, flags);
452 }
453 return rc;
454}
455
456static void sidtab_destroy_tree(union sidtab_entry_inner entry, u32 level)
457{
458 u32 i;
459
460 if (level != 0) {
461 struct sidtab_node_inner *node = entry.ptr_inner;
462
463 if (!node)
464 return;
465
466 for (i = 0; i < SIDTAB_INNER_ENTRIES; i++)
467 sidtab_destroy_tree(node->entries[i], level - 1);
468 kfree(node);
469 } else {
470 struct sidtab_node_leaf *node = entry.ptr_leaf;
471
472 if (!node)
473 return;
474
475 for (i = 0; i < SIDTAB_LEAF_ENTRIES; i++)
476 context_destroy(&node->entries[i].context);
477 kfree(node);
478 }
479}
480
481void sidtab_destroy(struct sidtab *s)
482{
483 u32 i, level;
484
485 for (i = 0; i < SECINITSID_NUM; i++)
486 if (s->isids[i].set)
487 context_destroy(&s->isids[i].context);
488
489 level = SIDTAB_MAX_LEVEL;
490 while (level && !s->roots[level].ptr_inner)
491 --level;
492
493 sidtab_destroy_tree(s->roots[level], level);
494}