blob: 5a2aec358322a930a5e6473a9e22acd64462298b [file] [log] [blame]
John Johansen736ec7522010-07-29 14:48:02 -07001/*
2 * AppArmor security module
3 *
4 * This file contains AppArmor functions for unpacking policy loaded from
5 * userspace.
6 *
7 * Copyright (C) 1998-2008 Novell/SUSE
8 * Copyright 2009-2010 Canonical Ltd.
9 *
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License as
12 * published by the Free Software Foundation, version 2 of the
13 * License.
14 *
Randy Dunlapd410fa42011-05-19 15:59:38 -070015 * AppArmor uses a serialized binary format for loading policy. To find
Kees Cook26fccd92017-05-13 04:51:45 -070016 * policy format documentation see Documentation/admin-guide/LSM/apparmor.rst
John Johansen736ec7522010-07-29 14:48:02 -070017 * All policy is validated before it is used.
18 */
19
20#include <asm/unaligned.h>
21#include <linux/ctype.h>
22#include <linux/errno.h>
23
24#include "include/apparmor.h"
25#include "include/audit.h"
26#include "include/context.h"
John Johansenf8eb8a12013-08-14 11:27:36 -070027#include "include/crypto.h"
John Johansen736ec7522010-07-29 14:48:02 -070028#include "include/match.h"
John Johansen637f6882017-06-09 08:14:28 -070029#include "include/path.h"
John Johansen736ec7522010-07-29 14:48:02 -070030#include "include/policy.h"
31#include "include/policy_unpack.h"
John Johansen736ec7522010-07-29 14:48:02 -070032
John Johansen474d6b752017-01-16 00:42:39 -080033#define K_ABI_MASK 0x3ff
John Johansen5ebfb122017-01-16 00:42:38 -080034#define FORCE_COMPLAIN_FLAG 0x800
John Johansen474d6b752017-01-16 00:42:39 -080035#define VERSION_LT(X, Y) (((X) & K_ABI_MASK) < ((Y) & K_ABI_MASK))
36#define VERSION_GT(X, Y) (((X) & K_ABI_MASK) > ((Y) & K_ABI_MASK))
37
38#define v5 5 /* base version */
39#define v6 6 /* per entry policydb mediation check */
40#define v7 7 /* full network masking */
John Johansen5ebfb122017-01-16 00:42:38 -080041
John Johansen736ec7522010-07-29 14:48:02 -070042/*
43 * The AppArmor interface treats data as a type byte followed by the
44 * actual data. The interface has the notion of a a named entry
45 * which has a name (AA_NAME typecode followed by name string) followed by
46 * the entries typecode and data. Named types allow for optional
47 * elements and extensions to be added and tested for without breaking
48 * backwards compatibility.
49 */
50
51enum aa_code {
52 AA_U8,
53 AA_U16,
54 AA_U32,
55 AA_U64,
56 AA_NAME, /* same as string except it is items name */
57 AA_STRING,
58 AA_BLOB,
59 AA_STRUCT,
60 AA_STRUCTEND,
61 AA_LIST,
62 AA_LISTEND,
63 AA_ARRAY,
64 AA_ARRAYEND,
65};
66
67/*
68 * aa_ext is the read of the buffer containing the serialized profile. The
69 * data is copied into a kernel buffer in apparmorfs and then handed off to
70 * the unpack routines.
71 */
72struct aa_ext {
73 void *start;
74 void *end;
75 void *pos; /* pointer to current position in the buffer */
76 u32 version;
77};
78
79/* audit callback for unpack fields */
80static void audit_cb(struct audit_buffer *ab, void *va)
81{
82 struct common_audit_data *sa = va;
John Johansenef88a7a2017-01-16 00:43:02 -080083
84 if (aad(sa)->iface.ns) {
85 audit_log_format(ab, " ns=");
86 audit_log_untrustedstring(ab, aad(sa)->iface.ns);
John Johansen736ec7522010-07-29 14:48:02 -070087 }
John Johansen2410aa92017-07-18 23:37:18 -070088 if (aad(sa)->name) {
John Johansenef88a7a2017-01-16 00:43:02 -080089 audit_log_format(ab, " name=");
John Johansen2410aa92017-07-18 23:37:18 -070090 audit_log_untrustedstring(ab, aad(sa)->name);
John Johansenef88a7a2017-01-16 00:43:02 -080091 }
92 if (aad(sa)->iface.pos)
93 audit_log_format(ab, " offset=%ld", aad(sa)->iface.pos);
John Johansen736ec7522010-07-29 14:48:02 -070094}
95
96/**
97 * audit_iface - do audit message for policy unpacking/load/replace/remove
98 * @new: profile if it has been allocated (MAYBE NULL)
John Johansen04dc7152017-01-16 00:42:56 -080099 * @ns_name: name of the ns the profile is to be loaded to (MAY BE NULL)
John Johansen736ec7522010-07-29 14:48:02 -0700100 * @name: name of the profile being manipulated (MAYBE NULL)
101 * @info: any extra info about the failure (MAYBE NULL)
John Johansenb1b4bc22012-03-10 11:25:30 -0800102 * @e: buffer position info
John Johansen736ec7522010-07-29 14:48:02 -0700103 * @error: error code
104 *
105 * Returns: %0 or error
106 */
John Johansen04dc7152017-01-16 00:42:56 -0800107static int audit_iface(struct aa_profile *new, const char *ns_name,
108 const char *name, const char *info, struct aa_ext *e,
109 int error)
John Johansen736ec7522010-07-29 14:48:02 -0700110{
John Johansen637f6882017-06-09 08:14:28 -0700111 struct aa_profile *profile = labels_profile(aa_current_raw_label());
John Johansenef88a7a2017-01-16 00:43:02 -0800112 DEFINE_AUDIT_DATA(sa, LSM_AUDIT_DATA_NONE, NULL);
John Johansenb1b4bc22012-03-10 11:25:30 -0800113 if (e)
John Johansenef88a7a2017-01-16 00:43:02 -0800114 aad(&sa)->iface.pos = e->pos - e->start;
115 aad(&sa)->iface.ns = ns_name;
116 if (new)
John Johansen2410aa92017-07-18 23:37:18 -0700117 aad(&sa)->name = new->base.hname;
John Johansenef88a7a2017-01-16 00:43:02 -0800118 else
John Johansen2410aa92017-07-18 23:37:18 -0700119 aad(&sa)->name = name;
John Johansenef88a7a2017-01-16 00:43:02 -0800120 aad(&sa)->info = info;
121 aad(&sa)->error = error;
John Johansen736ec7522010-07-29 14:48:02 -0700122
John Johansenef88a7a2017-01-16 00:43:02 -0800123 return aa_audit(AUDIT_APPARMOR_STATUS, profile, &sa, audit_cb);
John Johansen736ec7522010-07-29 14:48:02 -0700124}
125
John Johansen5d5182ca2017-05-09 00:08:41 -0700126void __aa_loaddata_update(struct aa_loaddata *data, long revision)
127{
128 AA_BUG(!data);
129 AA_BUG(!data->ns);
130 AA_BUG(!data->dents[AAFS_LOADDATA_REVISION]);
131 AA_BUG(!mutex_is_locked(&data->ns->lock));
132 AA_BUG(data->revision > revision);
133
134 data->revision = revision;
135 d_inode(data->dents[AAFS_LOADDATA_DIR])->i_mtime =
136 current_time(d_inode(data->dents[AAFS_LOADDATA_DIR]));
137 d_inode(data->dents[AAFS_LOADDATA_REVISION])->i_mtime =
138 current_time(d_inode(data->dents[AAFS_LOADDATA_REVISION]));
139}
140
141bool aa_rawdata_eq(struct aa_loaddata *l, struct aa_loaddata *r)
142{
143 if (l->size != r->size)
144 return false;
145 if (aa_g_hash_policy && memcmp(l->hash, r->hash, aa_hash_size()) != 0)
146 return false;
147 return memcmp(l->data, r->data, r->size) == 0;
148}
149
150/*
151 * need to take the ns mutex lock which is NOT safe most places that
152 * put_loaddata is called, so we have to delay freeing it
153 */
154static void do_loaddata_free(struct work_struct *work)
155{
156 struct aa_loaddata *d = container_of(work, struct aa_loaddata, work);
157 struct aa_ns *ns = aa_get_ns(d->ns);
158
159 if (ns) {
160 mutex_lock(&ns->lock);
161 __aa_fs_remove_rawdata(d);
162 mutex_unlock(&ns->lock);
163 aa_put_ns(ns);
164 }
165
166 kzfree(d->hash);
167 kfree(d->name);
168 kvfree(d);
169}
170
John Johansen5ac8c352017-01-16 00:42:55 -0800171void aa_loaddata_kref(struct kref *kref)
172{
173 struct aa_loaddata *d = container_of(kref, struct aa_loaddata, count);
174
175 if (d) {
John Johansen5d5182ca2017-05-09 00:08:41 -0700176 INIT_WORK(&d->work, do_loaddata_free);
177 schedule_work(&d->work);
John Johansen5ac8c352017-01-16 00:42:55 -0800178 }
179}
180
John Johansen5d5182ca2017-05-09 00:08:41 -0700181struct aa_loaddata *aa_loaddata_alloc(size_t size)
182{
183 struct aa_loaddata *d = kvzalloc(sizeof(*d) + size, GFP_KERNEL);
184
185 if (d == NULL)
186 return ERR_PTR(-ENOMEM);
187 kref_init(&d->count);
188 INIT_LIST_HEAD(&d->list);
189
190 return d;
191}
192
John Johansen736ec7522010-07-29 14:48:02 -0700193/* test if read will be in packed data bounds */
194static bool inbounds(struct aa_ext *e, size_t size)
195{
196 return (size <= e->end - e->pos);
197}
198
199/**
200 * aa_u16_chunck - test and do bounds checking for a u16 size based chunk
201 * @e: serialized data read head (NOT NULL)
202 * @chunk: start address for chunk of data (NOT NULL)
203 *
204 * Returns: the size of chunk found with the read head at the end of the chunk.
205 */
206static size_t unpack_u16_chunk(struct aa_ext *e, char **chunk)
207{
208 size_t size = 0;
209
210 if (!inbounds(e, sizeof(u16)))
211 return 0;
John Johansen2c17cd32017-01-16 00:43:14 -0800212 size = le16_to_cpu(get_unaligned((__le16 *) e->pos));
213 e->pos += sizeof(__le16);
John Johansen736ec7522010-07-29 14:48:02 -0700214 if (!inbounds(e, size))
215 return 0;
216 *chunk = e->pos;
217 e->pos += size;
218 return size;
219}
220
221/* unpack control byte */
222static bool unpack_X(struct aa_ext *e, enum aa_code code)
223{
224 if (!inbounds(e, 1))
225 return 0;
226 if (*(u8 *) e->pos != code)
227 return 0;
228 e->pos++;
229 return 1;
230}
231
232/**
233 * unpack_nameX - check is the next element is of type X with a name of @name
234 * @e: serialized data extent information (NOT NULL)
235 * @code: type code
236 * @name: name to match to the serialized element. (MAYBE NULL)
237 *
238 * check that the next serialized data element is of type X and has a tag
239 * name @name. If @name is specified then there must be a matching
240 * name element in the stream. If @name is NULL any name element will be
241 * skipped and only the typecode will be tested.
242 *
243 * Returns 1 on success (both type code and name tests match) and the read
244 * head is advanced past the headers
245 *
246 * Returns: 0 if either match fails, the read head does not move
247 */
248static bool unpack_nameX(struct aa_ext *e, enum aa_code code, const char *name)
249{
250 /*
251 * May need to reset pos if name or type doesn't match
252 */
253 void *pos = e->pos;
254 /*
255 * Check for presence of a tagname, and if present name size
256 * AA_NAME tag value is a u16.
257 */
258 if (unpack_X(e, AA_NAME)) {
259 char *tag = NULL;
260 size_t size = unpack_u16_chunk(e, &tag);
261 /* if a name is specified it must match. otherwise skip tag */
262 if (name && (!size || strcmp(name, tag)))
263 goto fail;
264 } else if (name) {
265 /* if a name is specified and there is no name tag fail */
266 goto fail;
267 }
268
269 /* now check if type code matches */
270 if (unpack_X(e, code))
271 return 1;
272
273fail:
274 e->pos = pos;
275 return 0;
276}
277
John Johansen651e28c2017-07-18 23:18:33 -0700278static bool unpack_u16(struct aa_ext *e, u16 *data, const char *name)
279{
280 if (unpack_nameX(e, AA_U16, name)) {
281 if (!inbounds(e, sizeof(u16)))
282 return 0;
283 if (data)
284 *data = le16_to_cpu(get_unaligned((__le16 *) e->pos));
285 e->pos += sizeof(u16);
286 return 1;
287 }
288 return 0;
289}
290
John Johansen736ec7522010-07-29 14:48:02 -0700291static bool unpack_u32(struct aa_ext *e, u32 *data, const char *name)
292{
293 if (unpack_nameX(e, AA_U32, name)) {
294 if (!inbounds(e, sizeof(u32)))
295 return 0;
296 if (data)
John Johansen2c17cd32017-01-16 00:43:14 -0800297 *data = le32_to_cpu(get_unaligned((__le32 *) e->pos));
John Johansen736ec7522010-07-29 14:48:02 -0700298 e->pos += sizeof(u32);
299 return 1;
300 }
301 return 0;
302}
303
304static bool unpack_u64(struct aa_ext *e, u64 *data, const char *name)
305{
306 if (unpack_nameX(e, AA_U64, name)) {
307 if (!inbounds(e, sizeof(u64)))
308 return 0;
309 if (data)
John Johansen2c17cd32017-01-16 00:43:14 -0800310 *data = le64_to_cpu(get_unaligned((__le64 *) e->pos));
John Johansen736ec7522010-07-29 14:48:02 -0700311 e->pos += sizeof(u64);
312 return 1;
313 }
314 return 0;
315}
316
317static size_t unpack_array(struct aa_ext *e, const char *name)
318{
319 if (unpack_nameX(e, AA_ARRAY, name)) {
320 int size;
321 if (!inbounds(e, sizeof(u16)))
322 return 0;
John Johansen2c17cd32017-01-16 00:43:14 -0800323 size = (int)le16_to_cpu(get_unaligned((__le16 *) e->pos));
John Johansen736ec7522010-07-29 14:48:02 -0700324 e->pos += sizeof(u16);
325 return size;
326 }
327 return 0;
328}
329
330static size_t unpack_blob(struct aa_ext *e, char **blob, const char *name)
331{
332 if (unpack_nameX(e, AA_BLOB, name)) {
333 u32 size;
334 if (!inbounds(e, sizeof(u32)))
335 return 0;
John Johansen2c17cd32017-01-16 00:43:14 -0800336 size = le32_to_cpu(get_unaligned((__le32 *) e->pos));
John Johansen736ec7522010-07-29 14:48:02 -0700337 e->pos += sizeof(u32);
338 if (inbounds(e, (size_t) size)) {
339 *blob = e->pos;
340 e->pos += size;
341 return size;
342 }
343 }
344 return 0;
345}
346
347static int unpack_str(struct aa_ext *e, const char **string, const char *name)
348{
349 char *src_str;
350 size_t size = 0;
351 void *pos = e->pos;
352 *string = NULL;
353 if (unpack_nameX(e, AA_STRING, name)) {
354 size = unpack_u16_chunk(e, &src_str);
355 if (size) {
356 /* strings are null terminated, length is size - 1 */
357 if (src_str[size - 1] != 0)
358 goto fail;
359 *string = src_str;
360 }
361 }
362 return size;
363
364fail:
365 e->pos = pos;
366 return 0;
367}
368
369static int unpack_strdup(struct aa_ext *e, char **string, const char *name)
370{
371 const char *tmp;
372 void *pos = e->pos;
373 int res = unpack_str(e, &tmp, name);
374 *string = NULL;
375
376 if (!res)
377 return 0;
378
379 *string = kmemdup(tmp, res, GFP_KERNEL);
380 if (!*string) {
381 e->pos = pos;
382 return 0;
383 }
384
385 return res;
386}
387
John Johansen180a6f52013-02-18 16:09:34 -0800388#define DFA_VALID_PERM_MASK 0xffffffff
389#define DFA_VALID_PERM2_MASK 0xffffffff
390
John Johansen736ec7522010-07-29 14:48:02 -0700391/**
392 * verify_accept - verify the accept tables of a dfa
393 * @dfa: dfa to verify accept tables of (NOT NULL)
394 * @flags: flags governing dfa
395 *
396 * Returns: 1 if valid accept tables else 0 if error
397 */
398static bool verify_accept(struct aa_dfa *dfa, int flags)
399{
400 int i;
401
402 /* verify accept permissions */
403 for (i = 0; i < dfa->tables[YYTD_ID_ACCEPT]->td_lolen; i++) {
404 int mode = ACCEPT_TABLE(dfa)[i];
405
406 if (mode & ~DFA_VALID_PERM_MASK)
407 return 0;
408
409 if (ACCEPT_TABLE2(dfa)[i] & ~DFA_VALID_PERM2_MASK)
410 return 0;
411 }
412 return 1;
413}
414
415/**
416 * unpack_dfa - unpack a file rule dfa
417 * @e: serialized data extent information (NOT NULL)
418 *
419 * returns dfa or ERR_PTR or NULL if no dfa
420 */
421static struct aa_dfa *unpack_dfa(struct aa_ext *e)
422{
423 char *blob = NULL;
424 size_t size;
425 struct aa_dfa *dfa = NULL;
426
427 size = unpack_blob(e, &blob, "aadfa");
428 if (size) {
429 /*
430 * The dfa is aligned with in the blob to 8 bytes
431 * from the beginning of the stream.
John Johansendd51c8482013-07-10 21:05:43 -0700432 * alignment adjust needed by dfa unpack
John Johansen736ec7522010-07-29 14:48:02 -0700433 */
John Johansendd51c8482013-07-10 21:05:43 -0700434 size_t sz = blob - (char *) e->start -
435 ((e->pos - e->start) & 7);
John Johansen736ec7522010-07-29 14:48:02 -0700436 size_t pad = ALIGN(sz, 8) - sz;
437 int flags = TO_ACCEPT1_FLAG(YYTD_DATA32) |
John Johansenabbf8732017-01-16 00:42:37 -0800438 TO_ACCEPT2_FLAG(YYTD_DATA32) | DFA_FLAG_VERIFY_STATES;
John Johansen736ec7522010-07-29 14:48:02 -0700439 dfa = aa_dfa_unpack(blob + pad, size - pad, flags);
440
441 if (IS_ERR(dfa))
442 return dfa;
443
444 if (!verify_accept(dfa, flags))
445 goto fail;
446 }
447
448 return dfa;
449
450fail:
451 aa_put_dfa(dfa);
452 return ERR_PTR(-EPROTO);
453}
454
455/**
456 * unpack_trans_table - unpack a profile transition table
457 * @e: serialized data extent information (NOT NULL)
458 * @profile: profile to add the accept table to (NOT NULL)
459 *
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300460 * Returns: 1 if table successfully unpacked
John Johansen736ec7522010-07-29 14:48:02 -0700461 */
462static bool unpack_trans_table(struct aa_ext *e, struct aa_profile *profile)
463{
Geert Uytterhoeven19fe43a2017-07-06 10:56:21 +0200464 void *saved_pos = e->pos;
John Johansen736ec7522010-07-29 14:48:02 -0700465
466 /* exec table is optional */
467 if (unpack_nameX(e, AA_STRUCT, "xtable")) {
468 int i, size;
469
470 size = unpack_array(e, NULL);
471 /* currently 4 exec bits and entries 0-3 are reserved iupcx */
472 if (size > 16 - 4)
473 goto fail;
474 profile->file.trans.table = kzalloc(sizeof(char *) * size,
475 GFP_KERNEL);
476 if (!profile->file.trans.table)
477 goto fail;
478
479 profile->file.trans.size = size;
480 for (i = 0; i < size; i++) {
481 char *str;
John Johansen5379a332017-06-09 17:29:12 -0700482 int c, j, pos, size2 = unpack_strdup(e, &str, NULL);
John Johansen736ec7522010-07-29 14:48:02 -0700483 /* unpack_strdup verifies that the last character is
484 * null termination byte.
485 */
James Morris7ee95852011-08-29 11:43:02 +1000486 if (!size2)
John Johansen736ec7522010-07-29 14:48:02 -0700487 goto fail;
488 profile->file.trans.table[i] = str;
489 /* verify that name doesn't start with space */
490 if (isspace(*str))
491 goto fail;
492
493 /* count internal # of internal \0 */
John Johansen5379a332017-06-09 17:29:12 -0700494 for (c = j = 0; j < size2 - 1; j++) {
495 if (!str[j]) {
496 pos = j;
John Johansen736ec7522010-07-29 14:48:02 -0700497 c++;
John Johansen5379a332017-06-09 17:29:12 -0700498 }
John Johansen736ec7522010-07-29 14:48:02 -0700499 }
500 if (*str == ':') {
John Johansen5379a332017-06-09 17:29:12 -0700501 /* first character after : must be valid */
502 if (!str[1])
503 goto fail;
John Johansen736ec7522010-07-29 14:48:02 -0700504 /* beginning with : requires an embedded \0,
505 * verify that exactly 1 internal \0 exists
506 * trailing \0 already verified by unpack_strdup
John Johansen5379a332017-06-09 17:29:12 -0700507 *
508 * convert \0 back to : for label_parse
John Johansen736ec7522010-07-29 14:48:02 -0700509 */
John Johansen5379a332017-06-09 17:29:12 -0700510 if (c == 1)
511 str[pos] = ':';
512 else if (c > 1)
John Johansen736ec7522010-07-29 14:48:02 -0700513 goto fail;
514 } else if (c)
515 /* fail - all other cases with embedded \0 */
516 goto fail;
517 }
518 if (!unpack_nameX(e, AA_ARRAYEND, NULL))
519 goto fail;
520 if (!unpack_nameX(e, AA_STRUCTEND, NULL))
521 goto fail;
522 }
523 return 1;
524
525fail:
526 aa_free_domain_entries(&profile->file.trans);
Geert Uytterhoeven19fe43a2017-07-06 10:56:21 +0200527 e->pos = saved_pos;
John Johansen736ec7522010-07-29 14:48:02 -0700528 return 0;
529}
530
531static bool unpack_rlimits(struct aa_ext *e, struct aa_profile *profile)
532{
533 void *pos = e->pos;
534
535 /* rlimits are optional */
536 if (unpack_nameX(e, AA_STRUCT, "rlimits")) {
537 int i, size;
538 u32 tmp = 0;
539 if (!unpack_u32(e, &tmp, NULL))
540 goto fail;
541 profile->rlimits.mask = tmp;
542
543 size = unpack_array(e, NULL);
544 if (size > RLIM_NLIMITS)
545 goto fail;
546 for (i = 0; i < size; i++) {
James Morris7ee95852011-08-29 11:43:02 +1000547 u64 tmp2 = 0;
John Johansen736ec7522010-07-29 14:48:02 -0700548 int a = aa_map_resource(i);
James Morris7ee95852011-08-29 11:43:02 +1000549 if (!unpack_u64(e, &tmp2, NULL))
John Johansen736ec7522010-07-29 14:48:02 -0700550 goto fail;
James Morris7ee95852011-08-29 11:43:02 +1000551 profile->rlimits.limits[a].rlim_max = tmp2;
John Johansen736ec7522010-07-29 14:48:02 -0700552 }
553 if (!unpack_nameX(e, AA_ARRAYEND, NULL))
554 goto fail;
555 if (!unpack_nameX(e, AA_STRUCTEND, NULL))
556 goto fail;
557 }
558 return 1;
559
560fail:
561 e->pos = pos;
562 return 0;
563}
564
William Huae025be02017-01-15 16:49:28 -0800565static void *kvmemdup(const void *src, size_t len)
566{
Michal Hockoa7c3e902017-05-08 15:57:09 -0700567 void *p = kvmalloc(len, GFP_KERNEL);
William Huae025be02017-01-15 16:49:28 -0800568
569 if (p)
570 memcpy(p, src, len);
571 return p;
572}
573
574static u32 strhash(const void *data, u32 len, u32 seed)
575{
576 const char * const *key = data;
577
578 return jhash(*key, strlen(*key), seed);
579}
580
581static int datacmp(struct rhashtable_compare_arg *arg, const void *obj)
582{
583 const struct aa_data *data = obj;
584 const char * const *key = arg->key;
585
586 return strcmp(data->key, *key);
587}
588
John Johansen736ec7522010-07-29 14:48:02 -0700589/**
590 * unpack_profile - unpack a serialized profile
591 * @e: serialized data extent information (NOT NULL)
592 *
593 * NOTE: unpack profile sets audit struct if there is a failure
594 */
John Johansen04dc7152017-01-16 00:42:56 -0800595static struct aa_profile *unpack_profile(struct aa_ext *e, char **ns_name)
John Johansen736ec7522010-07-29 14:48:02 -0700596{
597 struct aa_profile *profile = NULL;
John Johansen04dc7152017-01-16 00:42:56 -0800598 const char *tmpname, *tmpns = NULL, *name = NULL;
John Johansen2410aa92017-07-18 23:37:18 -0700599 const char *info = "failed to unpack profile";
John Johansen651e28c2017-07-18 23:18:33 -0700600 size_t size = 0, ns_len;
William Huae025be02017-01-15 16:49:28 -0800601 struct rhashtable_params params = { 0 };
602 char *key = NULL;
603 struct aa_data *data;
John Johansenad5ff3d2012-02-16 07:07:53 -0800604 int i, error = -EPROTO;
John Johansen736ec7522010-07-29 14:48:02 -0700605 kernel_cap_t tmpcap;
606 u32 tmp;
607
John Johansen04dc7152017-01-16 00:42:56 -0800608 *ns_name = NULL;
609
John Johansen736ec7522010-07-29 14:48:02 -0700610 /* check that we have the right struct being passed */
611 if (!unpack_nameX(e, AA_STRUCT, "profile"))
612 goto fail;
613 if (!unpack_str(e, &name, NULL))
614 goto fail;
John Johansen04dc7152017-01-16 00:42:56 -0800615 if (*name == '\0')
616 goto fail;
617
618 tmpname = aa_splitn_fqname(name, strlen(name), &tmpns, &ns_len);
619 if (tmpns) {
620 *ns_name = kstrndup(tmpns, ns_len, GFP_KERNEL);
John Johansen2410aa92017-07-18 23:37:18 -0700621 if (!*ns_name) {
622 info = "out of memory";
John Johansen04dc7152017-01-16 00:42:56 -0800623 goto fail;
John Johansen2410aa92017-07-18 23:37:18 -0700624 }
John Johansen04dc7152017-01-16 00:42:56 -0800625 name = tmpname;
626 }
John Johansen736ec7522010-07-29 14:48:02 -0700627
John Johansen637f6882017-06-09 08:14:28 -0700628 profile = aa_alloc_profile(name, NULL, GFP_KERNEL);
John Johansen736ec7522010-07-29 14:48:02 -0700629 if (!profile)
630 return ERR_PTR(-ENOMEM);
631
632 /* profile renaming is optional */
633 (void) unpack_str(e, &profile->rename, "rename");
634
John Johansen556d0be2013-07-10 21:17:43 -0700635 /* attachment string is optional */
636 (void) unpack_str(e, &profile->attach, "attach");
637
John Johansen736ec7522010-07-29 14:48:02 -0700638 /* xmatch is optional and may be NULL */
639 profile->xmatch = unpack_dfa(e);
640 if (IS_ERR(profile->xmatch)) {
641 error = PTR_ERR(profile->xmatch);
642 profile->xmatch = NULL;
John Johansen2410aa92017-07-18 23:37:18 -0700643 info = "bad xmatch";
John Johansen736ec7522010-07-29 14:48:02 -0700644 goto fail;
645 }
646 /* xmatch_len is not optional if xmatch is set */
647 if (profile->xmatch) {
John Johansen2410aa92017-07-18 23:37:18 -0700648 if (!unpack_u32(e, &tmp, NULL)) {
649 info = "missing xmatch len";
John Johansen736ec7522010-07-29 14:48:02 -0700650 goto fail;
John Johansen2410aa92017-07-18 23:37:18 -0700651 }
John Johansen736ec7522010-07-29 14:48:02 -0700652 profile->xmatch_len = tmp;
653 }
654
John Johansen72c8a762017-05-22 03:06:52 -0700655 /* disconnected attachment string is optional */
656 (void) unpack_str(e, &profile->disconnected, "disconnected");
657
John Johansen736ec7522010-07-29 14:48:02 -0700658 /* per profile debug flags (complain, audit) */
John Johansen2410aa92017-07-18 23:37:18 -0700659 if (!unpack_nameX(e, AA_STRUCT, "flags")) {
660 info = "profile missing flags";
John Johansen736ec7522010-07-29 14:48:02 -0700661 goto fail;
John Johansen2410aa92017-07-18 23:37:18 -0700662 }
663 info = "failed to unpack profile flags";
John Johansen736ec7522010-07-29 14:48:02 -0700664 if (!unpack_u32(e, &tmp, NULL))
665 goto fail;
John Johansen03816502013-07-10 21:12:43 -0700666 if (tmp & PACKED_FLAG_HAT)
John Johansen637f6882017-06-09 08:14:28 -0700667 profile->label.flags |= FLAG_HAT;
John Johansen736ec7522010-07-29 14:48:02 -0700668 if (!unpack_u32(e, &tmp, NULL))
669 goto fail;
John Johansen5ebfb122017-01-16 00:42:38 -0800670 if (tmp == PACKED_MODE_COMPLAIN || (e->version & FORCE_COMPLAIN_FLAG))
John Johansen736ec7522010-07-29 14:48:02 -0700671 profile->mode = APPARMOR_COMPLAIN;
John Johansen03816502013-07-10 21:12:43 -0700672 else if (tmp == PACKED_MODE_KILL)
673 profile->mode = APPARMOR_KILL;
674 else if (tmp == PACKED_MODE_UNCONFINED)
675 profile->mode = APPARMOR_UNCONFINED;
John Johansen736ec7522010-07-29 14:48:02 -0700676 if (!unpack_u32(e, &tmp, NULL))
677 goto fail;
678 if (tmp)
679 profile->audit = AUDIT_ALL;
680
681 if (!unpack_nameX(e, AA_STRUCTEND, NULL))
682 goto fail;
683
684 /* path_flags is optional */
685 if (unpack_u32(e, &profile->path_flags, "path_flags"))
John Johansen637f6882017-06-09 08:14:28 -0700686 profile->path_flags |= profile->label.flags &
687 PATH_MEDIATE_DELETED;
John Johansen736ec7522010-07-29 14:48:02 -0700688 else
689 /* set a default value if path_flags field is not present */
John Johansen637f6882017-06-09 08:14:28 -0700690 profile->path_flags = PATH_MEDIATE_DELETED;
John Johansen736ec7522010-07-29 14:48:02 -0700691
John Johansen2410aa92017-07-18 23:37:18 -0700692 info = "failed to unpack profile capabilities";
John Johansen736ec7522010-07-29 14:48:02 -0700693 if (!unpack_u32(e, &(profile->caps.allow.cap[0]), NULL))
694 goto fail;
695 if (!unpack_u32(e, &(profile->caps.audit.cap[0]), NULL))
696 goto fail;
697 if (!unpack_u32(e, &(profile->caps.quiet.cap[0]), NULL))
698 goto fail;
699 if (!unpack_u32(e, &tmpcap.cap[0], NULL))
700 goto fail;
701
John Johansen2410aa92017-07-18 23:37:18 -0700702 info = "failed to unpack upper profile capabilities";
John Johansen736ec7522010-07-29 14:48:02 -0700703 if (unpack_nameX(e, AA_STRUCT, "caps64")) {
704 /* optional upper half of 64 bit caps */
705 if (!unpack_u32(e, &(profile->caps.allow.cap[1]), NULL))
706 goto fail;
707 if (!unpack_u32(e, &(profile->caps.audit.cap[1]), NULL))
708 goto fail;
709 if (!unpack_u32(e, &(profile->caps.quiet.cap[1]), NULL))
710 goto fail;
711 if (!unpack_u32(e, &(tmpcap.cap[1]), NULL))
712 goto fail;
713 if (!unpack_nameX(e, AA_STRUCTEND, NULL))
714 goto fail;
715 }
716
John Johansen2410aa92017-07-18 23:37:18 -0700717 info = "failed to unpack extended profile capabilities";
John Johansen736ec7522010-07-29 14:48:02 -0700718 if (unpack_nameX(e, AA_STRUCT, "capsx")) {
719 /* optional extended caps mediation mask */
720 if (!unpack_u32(e, &(profile->caps.extended.cap[0]), NULL))
721 goto fail;
722 if (!unpack_u32(e, &(profile->caps.extended.cap[1]), NULL))
723 goto fail;
John Johansencdbd2882012-02-16 07:06:41 -0800724 if (!unpack_nameX(e, AA_STRUCTEND, NULL))
725 goto fail;
John Johansen736ec7522010-07-29 14:48:02 -0700726 }
727
John Johansen2410aa92017-07-18 23:37:18 -0700728 if (!unpack_rlimits(e, profile)) {
729 info = "failed to unpack profile rlimits";
John Johansen736ec7522010-07-29 14:48:02 -0700730 goto fail;
John Johansen2410aa92017-07-18 23:37:18 -0700731 }
John Johansen736ec7522010-07-29 14:48:02 -0700732
John Johansen651e28c2017-07-18 23:18:33 -0700733 size = unpack_array(e, "net_allowed_af");
734 if (size) {
735
736 for (i = 0; i < size; i++) {
737 /* discard extraneous rules that this kernel will
738 * never request
739 */
740 if (i >= AF_MAX) {
741 u16 tmp;
742
743 if (!unpack_u16(e, &tmp, NULL) ||
744 !unpack_u16(e, &tmp, NULL) ||
745 !unpack_u16(e, &tmp, NULL))
746 goto fail;
747 continue;
748 }
749 if (!unpack_u16(e, &profile->net.allow[i], NULL))
750 goto fail;
751 if (!unpack_u16(e, &profile->net.audit[i], NULL))
752 goto fail;
753 if (!unpack_u16(e, &profile->net.quiet[i], NULL))
754 goto fail;
755 }
756 if (!unpack_nameX(e, AA_ARRAYEND, NULL))
757 goto fail;
758 }
759 if (VERSION_LT(e->version, v7)) {
760 /* pre v7 policy always allowed these */
761 profile->net.allow[AF_UNIX] = 0xffff;
762 profile->net.allow[AF_NETLINK] = 0xffff;
763 }
764
John Johansenad5ff3d2012-02-16 07:07:53 -0800765 if (unpack_nameX(e, AA_STRUCT, "policydb")) {
766 /* generic policy dfa - optional and may be NULL */
John Johansen2410aa92017-07-18 23:37:18 -0700767 info = "failed to unpack policydb";
John Johansenad5ff3d2012-02-16 07:07:53 -0800768 profile->policy.dfa = unpack_dfa(e);
769 if (IS_ERR(profile->policy.dfa)) {
770 error = PTR_ERR(profile->policy.dfa);
771 profile->policy.dfa = NULL;
772 goto fail;
John Johansen5f20fdf2016-06-15 10:00:55 +0300773 } else if (!profile->policy.dfa) {
774 error = -EPROTO;
775 goto fail;
John Johansenad5ff3d2012-02-16 07:07:53 -0800776 }
777 if (!unpack_u32(e, &profile->policy.start[0], "start"))
778 /* default start state */
779 profile->policy.start[0] = DFA_START;
780 /* setup class index */
781 for (i = AA_CLASS_FILE; i <= AA_CLASS_LAST; i++) {
782 profile->policy.start[i] =
783 aa_dfa_next(profile->policy.dfa,
784 profile->policy.start[0],
785 i);
786 }
787 if (!unpack_nameX(e, AA_STRUCTEND, NULL))
788 goto fail;
John Johansen11c236b2017-01-16 00:42:42 -0800789 } else
790 profile->policy.dfa = aa_get_dfa(nulldfa);
John Johansenad5ff3d2012-02-16 07:07:53 -0800791
John Johansen736ec7522010-07-29 14:48:02 -0700792 /* get file rules */
793 profile->file.dfa = unpack_dfa(e);
794 if (IS_ERR(profile->file.dfa)) {
795 error = PTR_ERR(profile->file.dfa);
796 profile->file.dfa = NULL;
John Johansen2410aa92017-07-18 23:37:18 -0700797 info = "failed to unpack profile file rules";
John Johansen736ec7522010-07-29 14:48:02 -0700798 goto fail;
John Johansen6604d4c2017-01-16 00:42:41 -0800799 } else if (profile->file.dfa) {
800 if (!unpack_u32(e, &profile->file.start, "dfa_start"))
801 /* default start state */
802 profile->file.start = DFA_START;
803 } else if (profile->policy.dfa &&
804 profile->policy.start[AA_CLASS_FILE]) {
805 profile->file.dfa = aa_get_dfa(profile->policy.dfa);
806 profile->file.start = profile->policy.start[AA_CLASS_FILE];
John Johansen11c236b2017-01-16 00:42:42 -0800807 } else
808 profile->file.dfa = aa_get_dfa(nulldfa);
John Johansen736ec7522010-07-29 14:48:02 -0700809
John Johansen2410aa92017-07-18 23:37:18 -0700810 if (!unpack_trans_table(e, profile)) {
811 info = "failed to unpack profile transition table";
John Johansen736ec7522010-07-29 14:48:02 -0700812 goto fail;
John Johansen2410aa92017-07-18 23:37:18 -0700813 }
John Johansen736ec7522010-07-29 14:48:02 -0700814
William Huae025be02017-01-15 16:49:28 -0800815 if (unpack_nameX(e, AA_STRUCT, "data")) {
John Johansen2410aa92017-07-18 23:37:18 -0700816 info = "out of memory";
William Huae025be02017-01-15 16:49:28 -0800817 profile->data = kzalloc(sizeof(*profile->data), GFP_KERNEL);
818 if (!profile->data)
819 goto fail;
820
821 params.nelem_hint = 3;
822 params.key_len = sizeof(void *);
823 params.key_offset = offsetof(struct aa_data, key);
824 params.head_offset = offsetof(struct aa_data, head);
825 params.hashfn = strhash;
826 params.obj_cmpfn = datacmp;
827
John Johansen2410aa92017-07-18 23:37:18 -0700828 if (rhashtable_init(profile->data, &params)) {
829 info = "failed to init key, value hash table";
William Huae025be02017-01-15 16:49:28 -0800830 goto fail;
John Johansen2410aa92017-07-18 23:37:18 -0700831 }
William Huae025be02017-01-15 16:49:28 -0800832
833 while (unpack_strdup(e, &key, NULL)) {
834 data = kzalloc(sizeof(*data), GFP_KERNEL);
835 if (!data) {
836 kzfree(key);
837 goto fail;
838 }
839
840 data->key = key;
841 data->size = unpack_blob(e, &data->data, NULL);
842 data->data = kvmemdup(data->data, data->size);
843 if (data->size && !data->data) {
844 kzfree(data->key);
845 kzfree(data);
846 goto fail;
847 }
848
849 rhashtable_insert_fast(profile->data, &data->head,
850 profile->data->p);
851 }
852
John Johansen2410aa92017-07-18 23:37:18 -0700853 if (!unpack_nameX(e, AA_STRUCTEND, NULL)) {
854 info = "failed to unpack end of key, value data table";
William Huae025be02017-01-15 16:49:28 -0800855 goto fail;
John Johansen2410aa92017-07-18 23:37:18 -0700856 }
William Huae025be02017-01-15 16:49:28 -0800857 }
858
John Johansen2410aa92017-07-18 23:37:18 -0700859 if (!unpack_nameX(e, AA_STRUCTEND, NULL)) {
860 info = "failed to unpack end of profile";
John Johansen736ec7522010-07-29 14:48:02 -0700861 goto fail;
John Johansen2410aa92017-07-18 23:37:18 -0700862 }
John Johansen736ec7522010-07-29 14:48:02 -0700863
864 return profile;
865
866fail:
867 if (profile)
868 name = NULL;
869 else if (!name)
870 name = "unknown";
John Johansen2410aa92017-07-18 23:37:18 -0700871 audit_iface(profile, NULL, name, info, e, error);
John Johansen8651e1d62013-07-10 21:11:43 -0700872 aa_free_profile(profile);
John Johansen736ec7522010-07-29 14:48:02 -0700873
874 return ERR_PTR(error);
875}
876
877/**
878 * verify_head - unpack serialized stream header
879 * @e: serialized data read head (NOT NULL)
John Johansendd51c8482013-07-10 21:05:43 -0700880 * @required: whether the header is required or optional
John Johansen736ec7522010-07-29 14:48:02 -0700881 * @ns: Returns - namespace if one is specified else NULL (NOT NULL)
882 *
883 * Returns: error or 0 if header is good
884 */
John Johansendd51c8482013-07-10 21:05:43 -0700885static int verify_header(struct aa_ext *e, int required, const char **ns)
John Johansen736ec7522010-07-29 14:48:02 -0700886{
887 int error = -EPROTONOSUPPORT;
John Johansendd51c8482013-07-10 21:05:43 -0700888 const char *name = NULL;
889 *ns = NULL;
890
John Johansen736ec7522010-07-29 14:48:02 -0700891 /* get the interface version */
892 if (!unpack_u32(e, &e->version, "version")) {
John Johansendd51c8482013-07-10 21:05:43 -0700893 if (required) {
John Johansen04dc7152017-01-16 00:42:56 -0800894 audit_iface(NULL, NULL, NULL, "invalid profile format",
John Johansendd51c8482013-07-10 21:05:43 -0700895 e, error);
896 return error;
897 }
John Johansen736ec7522010-07-29 14:48:02 -0700898 }
899
John Johansen474d6b752017-01-16 00:42:39 -0800900 /* Check that the interface version is currently supported.
901 * if not specified use previous version
902 * Mask off everything that is not kernel abi version
903 */
Christos Gkekas86aea562017-07-08 20:50:21 +0100904 if (VERSION_LT(e->version, v5) || VERSION_GT(e->version, v7)) {
John Johansen04dc7152017-01-16 00:42:56 -0800905 audit_iface(NULL, NULL, NULL, "unsupported interface version",
John Johansen474d6b752017-01-16 00:42:39 -0800906 e, error);
907 return error;
908 }
John Johansen736ec7522010-07-29 14:48:02 -0700909
910 /* read the namespace if present */
John Johansendd51c8482013-07-10 21:05:43 -0700911 if (unpack_str(e, &name, "namespace")) {
John Johansen04dc7152017-01-16 00:42:56 -0800912 if (*name == '\0') {
913 audit_iface(NULL, NULL, NULL, "invalid namespace name",
914 e, error);
915 return error;
916 }
John Johansendd51c8482013-07-10 21:05:43 -0700917 if (*ns && strcmp(*ns, name))
John Johansen04dc7152017-01-16 00:42:56 -0800918 audit_iface(NULL, NULL, NULL, "invalid ns change", e,
919 error);
John Johansendd51c8482013-07-10 21:05:43 -0700920 else if (!*ns)
921 *ns = name;
922 }
John Johansen736ec7522010-07-29 14:48:02 -0700923
924 return 0;
925}
926
927static bool verify_xindex(int xindex, int table_size)
928{
929 int index, xtype;
930 xtype = xindex & AA_X_TYPE_MASK;
931 index = xindex & AA_X_INDEX_MASK;
John Johansen23ca7b62016-03-17 12:02:54 -0700932 if (xtype == AA_X_TABLE && index >= table_size)
John Johansen736ec7522010-07-29 14:48:02 -0700933 return 0;
934 return 1;
935}
936
937/* verify dfa xindexes are in range of transition tables */
938static bool verify_dfa_xindex(struct aa_dfa *dfa, int table_size)
939{
940 int i;
941 for (i = 0; i < dfa->tables[YYTD_ID_ACCEPT]->td_lolen; i++) {
942 if (!verify_xindex(dfa_user_xindex(dfa, i), table_size))
943 return 0;
944 if (!verify_xindex(dfa_other_xindex(dfa, i), table_size))
945 return 0;
946 }
947 return 1;
948}
949
950/**
951 * verify_profile - Do post unpack analysis to verify profile consistency
952 * @profile: profile to verify (NOT NULL)
953 *
954 * Returns: 0 if passes verification else error
955 */
956static int verify_profile(struct aa_profile *profile)
957{
John Johansenabbf8732017-01-16 00:42:37 -0800958 if (profile->file.dfa &&
959 !verify_dfa_xindex(profile->file.dfa,
960 profile->file.trans.size)) {
John Johansen04dc7152017-01-16 00:42:56 -0800961 audit_iface(profile, NULL, NULL, "Invalid named transition",
John Johansenabbf8732017-01-16 00:42:37 -0800962 NULL, -EPROTO);
963 return -EPROTO;
John Johansen736ec7522010-07-29 14:48:02 -0700964 }
965
966 return 0;
967}
968
John Johansendd51c8482013-07-10 21:05:43 -0700969void aa_load_ent_free(struct aa_load_ent *ent)
970{
971 if (ent) {
972 aa_put_profile(ent->rename);
973 aa_put_profile(ent->old);
974 aa_put_profile(ent->new);
John Johansen04dc7152017-01-16 00:42:56 -0800975 kfree(ent->ns_name);
John Johansendd51c8482013-07-10 21:05:43 -0700976 kzfree(ent);
977 }
978}
979
980struct aa_load_ent *aa_load_ent_alloc(void)
981{
982 struct aa_load_ent *ent = kzalloc(sizeof(*ent), GFP_KERNEL);
983 if (ent)
984 INIT_LIST_HEAD(&ent->list);
985 return ent;
986}
987
John Johansen736ec7522010-07-29 14:48:02 -0700988/**
John Johansendd51c8482013-07-10 21:05:43 -0700989 * aa_unpack - unpack packed binary profile(s) data loaded from user space
John Johansen736ec7522010-07-29 14:48:02 -0700990 * @udata: user data copied to kmem (NOT NULL)
John Johansendd51c8482013-07-10 21:05:43 -0700991 * @lh: list to place unpacked profiles in a aa_repl_ws
John Johansen736ec7522010-07-29 14:48:02 -0700992 * @ns: Returns namespace profile is in if specified else NULL (NOT NULL)
993 *
John Johansendd51c8482013-07-10 21:05:43 -0700994 * Unpack user data and return refcounted allocated profile(s) stored in
995 * @lh in order of discovery, with the list chain stored in base.list
996 * or error
John Johansen736ec7522010-07-29 14:48:02 -0700997 *
John Johansendd51c8482013-07-10 21:05:43 -0700998 * Returns: profile(s) on @lh else error pointer if fails to unpack
John Johansen736ec7522010-07-29 14:48:02 -0700999 */
John Johansen5ac8c352017-01-16 00:42:55 -08001000int aa_unpack(struct aa_loaddata *udata, struct list_head *lh,
1001 const char **ns)
John Johansen736ec7522010-07-29 14:48:02 -07001002{
John Johansendd51c8482013-07-10 21:05:43 -07001003 struct aa_load_ent *tmp, *ent;
John Johansen736ec7522010-07-29 14:48:02 -07001004 struct aa_profile *profile = NULL;
1005 int error;
1006 struct aa_ext e = {
John Johansen5ac8c352017-01-16 00:42:55 -08001007 .start = udata->data,
1008 .end = udata->data + udata->size,
1009 .pos = udata->data,
John Johansen736ec7522010-07-29 14:48:02 -07001010 };
1011
John Johansendd51c8482013-07-10 21:05:43 -07001012 *ns = NULL;
1013 while (e.pos < e.end) {
John Johansen04dc7152017-01-16 00:42:56 -08001014 char *ns_name = NULL;
John Johansenf8eb8a12013-08-14 11:27:36 -07001015 void *start;
John Johansendd51c8482013-07-10 21:05:43 -07001016 error = verify_header(&e, e.pos == e.start, ns);
1017 if (error)
1018 goto fail;
John Johansen736ec7522010-07-29 14:48:02 -07001019
John Johansenf8eb8a12013-08-14 11:27:36 -07001020 start = e.pos;
John Johansen04dc7152017-01-16 00:42:56 -08001021 profile = unpack_profile(&e, &ns_name);
John Johansendd51c8482013-07-10 21:05:43 -07001022 if (IS_ERR(profile)) {
1023 error = PTR_ERR(profile);
1024 goto fail;
1025 }
John Johansen736ec7522010-07-29 14:48:02 -07001026
John Johansendd51c8482013-07-10 21:05:43 -07001027 error = verify_profile(profile);
John Johansenf8eb8a12013-08-14 11:27:36 -07001028 if (error)
1029 goto fail_profile;
1030
John Johansen31f75bf2017-01-16 00:43:07 -08001031 if (aa_g_hash_policy)
1032 error = aa_calc_profile_hash(profile, e.version, start,
John Johansen6059f712014-10-24 09:16:14 -07001033 e.pos - start);
John Johansenf8eb8a12013-08-14 11:27:36 -07001034 if (error)
1035 goto fail_profile;
John Johansendd51c8482013-07-10 21:05:43 -07001036
1037 ent = aa_load_ent_alloc();
1038 if (!ent) {
1039 error = -ENOMEM;
John Johansenf8eb8a12013-08-14 11:27:36 -07001040 goto fail_profile;
John Johansendd51c8482013-07-10 21:05:43 -07001041 }
1042
1043 ent->new = profile;
John Johansen04dc7152017-01-16 00:42:56 -08001044 ent->ns_name = ns_name;
John Johansendd51c8482013-07-10 21:05:43 -07001045 list_add_tail(&ent->list, lh);
John Johansen736ec7522010-07-29 14:48:02 -07001046 }
John Johansen5ac8c352017-01-16 00:42:55 -08001047 udata->abi = e.version & K_ABI_MASK;
John Johansen31f75bf2017-01-16 00:43:07 -08001048 if (aa_g_hash_policy) {
1049 udata->hash = aa_calc_hash(udata->data, udata->size);
1050 if (IS_ERR(udata->hash)) {
1051 error = PTR_ERR(udata->hash);
1052 udata->hash = NULL;
1053 goto fail;
1054 }
John Johansen5ac8c352017-01-16 00:42:55 -08001055 }
John Johansendd51c8482013-07-10 21:05:43 -07001056 return 0;
1057
John Johansenf8eb8a12013-08-14 11:27:36 -07001058fail_profile:
1059 aa_put_profile(profile);
1060
John Johansendd51c8482013-07-10 21:05:43 -07001061fail:
1062 list_for_each_entry_safe(ent, tmp, lh, list) {
1063 list_del_init(&ent->list);
1064 aa_load_ent_free(ent);
1065 }
1066
1067 return error;
John Johansen736ec7522010-07-29 14:48:02 -07001068}