1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Implementation of the SID table type.
4 *
5 * Author : Stephen Smalley, <sds@tycho.nsa.gov>
6 */
7 #include <linux/kernel.h>
8 #include <linux/slab.h>
9 #include <linux/spinlock.h>
10 #include <linux/errno.h>
11 #include "flask.h"
12 #include "security.h"
13 #include "sidtab.h"
14
15 #define SIDTAB_HASH(sid) \
16 (sid & SIDTAB_HASH_MASK)
17
sidtab_init(struct sidtab * s)18 int sidtab_init(struct sidtab *s)
19 {
20 int i;
21
22 s->htable = kmalloc_array(SIDTAB_SIZE, sizeof(*s->htable), GFP_ATOMIC);
23 if (!s->htable)
24 return -ENOMEM;
25 for (i = 0; i < SIDTAB_SIZE; i++)
26 s->htable[i] = NULL;
27 s->nel = 0;
28 s->next_sid = 1;
29 s->shutdown = 0;
30 spin_lock_init(&s->lock);
31 return 0;
32 }
33
sidtab_insert(struct sidtab * s,u32 sid,struct context * context)34 int sidtab_insert(struct sidtab *s, u32 sid, struct context *context)
35 {
36 int hvalue;
37 struct sidtab_node *prev, *cur, *newnode;
38
39 if (!s)
40 return -ENOMEM;
41
42 hvalue = SIDTAB_HASH(sid);
43 prev = NULL;
44 cur = s->htable[hvalue];
45 while (cur && sid > cur->sid) {
46 prev = cur;
47 cur = cur->next;
48 }
49
50 if (cur && sid == cur->sid)
51 return -EEXIST;
52
53 newnode = kmalloc(sizeof(*newnode), GFP_ATOMIC);
54 if (!newnode)
55 return -ENOMEM;
56
57 newnode->sid = sid;
58 if (context_cpy(&newnode->context, context)) {
59 kfree(newnode);
60 return -ENOMEM;
61 }
62
63 if (prev) {
64 newnode->next = prev->next;
65 wmb();
66 prev->next = newnode;
67 } else {
68 newnode->next = s->htable[hvalue];
69 wmb();
70 s->htable[hvalue] = newnode;
71 }
72
73 s->nel++;
74 if (sid >= s->next_sid)
75 s->next_sid = sid + 1;
76 return 0;
77 }
78
sidtab_search_core(struct sidtab * s,u32 sid,int force)79 static struct context *sidtab_search_core(struct sidtab *s, u32 sid, int force)
80 {
81 int hvalue;
82 struct sidtab_node *cur;
83
84 if (!s)
85 return NULL;
86
87 hvalue = SIDTAB_HASH(sid);
88 cur = s->htable[hvalue];
89 while (cur && sid > cur->sid)
90 cur = cur->next;
91
92 if (force && cur && sid == cur->sid && cur->context.len)
93 return &cur->context;
94
95 if (!cur || sid != cur->sid || cur->context.len) {
96 /* Remap invalid SIDs to the unlabeled SID. */
97 sid = SECINITSID_UNLABELED;
98 hvalue = SIDTAB_HASH(sid);
99 cur = s->htable[hvalue];
100 while (cur && sid > cur->sid)
101 cur = cur->next;
102 if (!cur || sid != cur->sid)
103 return NULL;
104 }
105
106 return &cur->context;
107 }
108
sidtab_search(struct sidtab * s,u32 sid)109 struct context *sidtab_search(struct sidtab *s, u32 sid)
110 {
111 return sidtab_search_core(s, sid, 0);
112 }
113
sidtab_search_force(struct sidtab * s,u32 sid)114 struct context *sidtab_search_force(struct sidtab *s, u32 sid)
115 {
116 return sidtab_search_core(s, sid, 1);
117 }
118
sidtab_map(struct sidtab * s,int (* apply)(u32 sid,struct context * context,void * args),void * args)119 int sidtab_map(struct sidtab *s,
120 int (*apply) (u32 sid,
121 struct context *context,
122 void *args),
123 void *args)
124 {
125 int i, rc = 0;
126 struct sidtab_node *cur;
127
128 if (!s)
129 goto out;
130
131 for (i = 0; i < SIDTAB_SIZE; i++) {
132 cur = s->htable[i];
133 while (cur) {
134 rc = apply(cur->sid, &cur->context, args);
135 if (rc)
136 goto out;
137 cur = cur->next;
138 }
139 }
140 out:
141 return rc;
142 }
143
sidtab_update_cache(struct sidtab * s,struct sidtab_node * n,int loc)144 static void sidtab_update_cache(struct sidtab *s, struct sidtab_node *n, int loc)
145 {
146 BUG_ON(loc >= SIDTAB_CACHE_LEN);
147
148 while (loc > 0) {
149 s->cache[loc] = s->cache[loc - 1];
150 loc--;
151 }
152 s->cache[0] = n;
153 }
154
sidtab_search_context(struct sidtab * s,struct context * context)155 static inline u32 sidtab_search_context(struct sidtab *s,
156 struct context *context)
157 {
158 int i;
159 struct sidtab_node *cur;
160
161 for (i = 0; i < SIDTAB_SIZE; i++) {
162 cur = s->htable[i];
163 while (cur) {
164 if (context_cmp(&cur->context, context)) {
165 sidtab_update_cache(s, cur, SIDTAB_CACHE_LEN - 1);
166 return cur->sid;
167 }
168 cur = cur->next;
169 }
170 }
171 return 0;
172 }
173
sidtab_search_cache(struct sidtab * s,struct context * context)174 static inline u32 sidtab_search_cache(struct sidtab *s, struct context *context)
175 {
176 int i;
177 struct sidtab_node *node;
178
179 for (i = 0; i < SIDTAB_CACHE_LEN; i++) {
180 node = s->cache[i];
181 if (unlikely(!node))
182 return 0;
183 if (context_cmp(&node->context, context)) {
184 sidtab_update_cache(s, node, i);
185 return node->sid;
186 }
187 }
188 return 0;
189 }
190
sidtab_context_to_sid(struct sidtab * s,struct context * context,u32 * out_sid)191 int sidtab_context_to_sid(struct sidtab *s,
192 struct context *context,
193 u32 *out_sid)
194 {
195 u32 sid;
196 int ret = 0;
197 unsigned long flags;
198
199 *out_sid = SECSID_NULL;
200
201 sid = sidtab_search_cache(s, context);
202 if (!sid)
203 sid = sidtab_search_context(s, context);
204 if (!sid) {
205 spin_lock_irqsave(&s->lock, flags);
206 /* Rescan now that we hold the lock. */
207 sid = sidtab_search_context(s, context);
208 if (sid)
209 goto unlock_out;
210 /* No SID exists for the context. Allocate a new one. */
211 if (s->next_sid == UINT_MAX || s->shutdown) {
212 ret = -ENOMEM;
213 goto unlock_out;
214 }
215 sid = s->next_sid++;
216 if (context->len)
217 pr_info("SELinux: Context %s is not valid (left unmapped).\n",
218 context->str);
219 ret = sidtab_insert(s, sid, context);
220 if (ret)
221 s->next_sid--;
222 unlock_out:
223 spin_unlock_irqrestore(&s->lock, flags);
224 }
225
226 if (ret)
227 return ret;
228
229 *out_sid = sid;
230 return 0;
231 }
232
sidtab_hash_eval(struct sidtab * h,char * tag)233 void sidtab_hash_eval(struct sidtab *h, char *tag)
234 {
235 int i, chain_len, slots_used, max_chain_len;
236 struct sidtab_node *cur;
237
238 slots_used = 0;
239 max_chain_len = 0;
240 for (i = 0; i < SIDTAB_SIZE; i++) {
241 cur = h->htable[i];
242 if (cur) {
243 slots_used++;
244 chain_len = 0;
245 while (cur) {
246 chain_len++;
247 cur = cur->next;
248 }
249
250 if (chain_len > max_chain_len)
251 max_chain_len = chain_len;
252 }
253 }
254
255 pr_debug("%s: %d entries and %d/%d buckets used, longest "
256 "chain length %d\n", tag, h->nel, slots_used, SIDTAB_SIZE,
257 max_chain_len);
258 }
259
sidtab_destroy(struct sidtab * s)260 void sidtab_destroy(struct sidtab *s)
261 {
262 int i;
263 struct sidtab_node *cur, *temp;
264
265 if (!s)
266 return;
267
268 for (i = 0; i < SIDTAB_SIZE; i++) {
269 cur = s->htable[i];
270 while (cur) {
271 temp = cur;
272 cur = cur->next;
273 context_destroy(&temp->context);
274 kfree(temp);
275 }
276 s->htable[i] = NULL;
277 }
278 kfree(s->htable);
279 s->htable = NULL;
280 s->nel = 0;
281 s->next_sid = 1;
282 }
283
sidtab_set(struct sidtab * dst,struct sidtab * src)284 void sidtab_set(struct sidtab *dst, struct sidtab *src)
285 {
286 unsigned long flags;
287 int i;
288
289 spin_lock_irqsave(&src->lock, flags);
290 dst->htable = src->htable;
291 dst->nel = src->nel;
292 dst->next_sid = src->next_sid;
293 dst->shutdown = 0;
294 for (i = 0; i < SIDTAB_CACHE_LEN; i++)
295 dst->cache[i] = NULL;
296 spin_unlock_irqrestore(&src->lock, flags);
297 }
298
sidtab_shutdown(struct sidtab * s)299 void sidtab_shutdown(struct sidtab *s)
300 {
301 unsigned long flags;
302
303 spin_lock_irqsave(&s->lock, flags);
304 s->shutdown = 1;
305 spin_unlock_irqrestore(&s->lock, flags);
306 }
307
