]>
git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - security/apparmor/policy_unpack.c
2 * AppArmor security module
4 * This file contains AppArmor functions for unpacking policy loaded from
7 * Copyright (C) 1998-2008 Novell/SUSE
8 * Copyright 2009-2010 Canonical Ltd.
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
15 * AppArmor uses a serialized binary format for loading policy. To find
16 * policy format documentation see Documentation/admin-guide/LSM/apparmor.rst
17 * All policy is validated before it is used.
20 #include <asm/unaligned.h>
21 #include <linux/ctype.h>
22 #include <linux/errno.h>
24 #include "include/apparmor.h"
25 #include "include/audit.h"
26 #include "include/context.h"
27 #include "include/crypto.h"
28 #include "include/match.h"
29 #include "include/path.h"
30 #include "include/policy.h"
31 #include "include/policy_unpack.h"
33 #define K_ABI_MASK 0x3ff
34 #define FORCE_COMPLAIN_FLAG 0x800
35 #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))
38 #define v5 5 /* base version */
39 #define v6 6 /* per entry policydb mediation check */
40 #define v7 7 /* full network masking */
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.
56 AA_NAME
, /* same as string except it is items name */
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.
75 void *pos
; /* pointer to current position in the buffer */
79 /* audit callback for unpack fields */
80 static void audit_cb(struct audit_buffer
*ab
, void *va
)
82 struct common_audit_data
*sa
= va
;
84 if (aad(sa
)->iface
.ns
) {
85 audit_log_format(ab
, " ns=");
86 audit_log_untrustedstring(ab
, aad(sa
)->iface
.ns
);
89 audit_log_format(ab
, " name=");
90 audit_log_untrustedstring(ab
, aad(sa
)->name
);
92 if (aad(sa
)->iface
.pos
)
93 audit_log_format(ab
, " offset=%ld", aad(sa
)->iface
.pos
);
97 * audit_iface - do audit message for policy unpacking/load/replace/remove
98 * @new: profile if it has been allocated (MAYBE NULL)
99 * @ns_name: name of the ns the profile is to be loaded to (MAY BE NULL)
100 * @name: name of the profile being manipulated (MAYBE NULL)
101 * @info: any extra info about the failure (MAYBE NULL)
102 * @e: buffer position info
105 * Returns: %0 or error
107 static int audit_iface(struct aa_profile
*new, const char *ns_name
,
108 const char *name
, const char *info
, struct aa_ext
*e
,
111 struct aa_profile
*profile
= labels_profile(aa_current_raw_label());
112 DEFINE_AUDIT_DATA(sa
, LSM_AUDIT_DATA_NONE
, NULL
);
114 aad(&sa
)->iface
.pos
= e
->pos
- e
->start
;
115 aad(&sa
)->iface
.ns
= ns_name
;
117 aad(&sa
)->name
= new->base
.hname
;
119 aad(&sa
)->name
= name
;
120 aad(&sa
)->info
= info
;
121 aad(&sa
)->error
= error
;
123 return aa_audit(AUDIT_APPARMOR_STATUS
, profile
, &sa
, audit_cb
);
126 void __aa_loaddata_update(struct aa_loaddata
*data
, long revision
)
130 AA_BUG(!data
->dents
[AAFS_LOADDATA_REVISION
]);
131 AA_BUG(!mutex_is_locked(&data
->ns
->lock
));
132 AA_BUG(data
->revision
> revision
);
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
]));
141 bool aa_rawdata_eq(struct aa_loaddata
*l
, struct aa_loaddata
*r
)
143 if (l
->size
!= r
->size
)
145 if (aa_g_hash_policy
&& memcmp(l
->hash
, r
->hash
, aa_hash_size()) != 0)
147 return memcmp(l
->data
, r
->data
, r
->size
) == 0;
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
154 static void do_loaddata_free(struct work_struct
*work
)
156 struct aa_loaddata
*d
= container_of(work
, struct aa_loaddata
, work
);
157 struct aa_ns
*ns
= aa_get_ns(d
->ns
);
160 mutex_lock_nested(&ns
->lock
, ns
->level
);
161 __aa_fs_remove_rawdata(d
);
162 mutex_unlock(&ns
->lock
);
171 void aa_loaddata_kref(struct kref
*kref
)
173 struct aa_loaddata
*d
= container_of(kref
, struct aa_loaddata
, count
);
176 INIT_WORK(&d
->work
, do_loaddata_free
);
177 schedule_work(&d
->work
);
181 struct aa_loaddata
*aa_loaddata_alloc(size_t size
)
183 struct aa_loaddata
*d
= kvzalloc(sizeof(*d
) + size
, GFP_KERNEL
);
186 return ERR_PTR(-ENOMEM
);
187 kref_init(&d
->count
);
188 INIT_LIST_HEAD(&d
->list
);
193 /* test if read will be in packed data bounds */
194 static bool inbounds(struct aa_ext
*e
, size_t size
)
196 return (size
<= e
->end
- e
->pos
);
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)
204 * Returns: the size of chunk found with the read head at the end of the chunk.
206 static size_t unpack_u16_chunk(struct aa_ext
*e
, char **chunk
)
210 if (!inbounds(e
, sizeof(u16
)))
212 size
= le16_to_cpu(get_unaligned((__le16
*) e
->pos
));
213 e
->pos
+= sizeof(__le16
);
214 if (!inbounds(e
, size
))
221 /* unpack control byte */
222 static bool unpack_X(struct aa_ext
*e
, enum aa_code code
)
226 if (*(u8
*) e
->pos
!= code
)
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)
236 * @name: name to match to the serialized element. (MAYBE NULL)
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.
243 * Returns 1 on success (both type code and name tests match) and the read
244 * head is advanced past the headers
246 * Returns: 0 if either match fails, the read head does not move
248 static bool unpack_nameX(struct aa_ext
*e
, enum aa_code code
, const char *name
)
251 * May need to reset pos if name or type doesn't match
255 * Check for presence of a tagname, and if present name size
256 * AA_NAME tag value is a u16.
258 if (unpack_X(e
, AA_NAME
)) {
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
)))
265 /* if a name is specified and there is no name tag fail */
269 /* now check if type code matches */
270 if (unpack_X(e
, code
))
278 static bool unpack_u16(struct aa_ext
*e
, u16
*data
, const char *name
)
280 if (unpack_nameX(e
, AA_U16
, name
)) {
281 if (!inbounds(e
, sizeof(u16
)))
284 *data
= le16_to_cpu(get_unaligned((__le16
*) e
->pos
));
285 e
->pos
+= sizeof(u16
);
291 static bool unpack_u32(struct aa_ext
*e
, u32
*data
, const char *name
)
293 if (unpack_nameX(e
, AA_U32
, name
)) {
294 if (!inbounds(e
, sizeof(u32
)))
297 *data
= le32_to_cpu(get_unaligned((__le32
*) e
->pos
));
298 e
->pos
+= sizeof(u32
);
304 static bool unpack_u64(struct aa_ext
*e
, u64
*data
, const char *name
)
306 if (unpack_nameX(e
, AA_U64
, name
)) {
307 if (!inbounds(e
, sizeof(u64
)))
310 *data
= le64_to_cpu(get_unaligned((__le64
*) e
->pos
));
311 e
->pos
+= sizeof(u64
);
317 static size_t unpack_array(struct aa_ext
*e
, const char *name
)
319 if (unpack_nameX(e
, AA_ARRAY
, name
)) {
321 if (!inbounds(e
, sizeof(u16
)))
323 size
= (int)le16_to_cpu(get_unaligned((__le16
*) e
->pos
));
324 e
->pos
+= sizeof(u16
);
330 static size_t unpack_blob(struct aa_ext
*e
, char **blob
, const char *name
)
332 if (unpack_nameX(e
, AA_BLOB
, name
)) {
334 if (!inbounds(e
, sizeof(u32
)))
336 size
= le32_to_cpu(get_unaligned((__le32
*) e
->pos
));
337 e
->pos
+= sizeof(u32
);
338 if (inbounds(e
, (size_t) size
)) {
347 static int unpack_str(struct aa_ext
*e
, const char **string
, const char *name
)
353 if (unpack_nameX(e
, AA_STRING
, name
)) {
354 size
= unpack_u16_chunk(e
, &src_str
);
356 /* strings are null terminated, length is size - 1 */
357 if (src_str
[size
- 1] != 0)
369 static int unpack_strdup(struct aa_ext
*e
, char **string
, const char *name
)
373 int res
= unpack_str(e
, &tmp
, name
);
379 *string
= kmemdup(tmp
, res
, GFP_KERNEL
);
388 #define DFA_VALID_PERM_MASK 0xffffffff
389 #define DFA_VALID_PERM2_MASK 0xffffffff
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
396 * Returns: 1 if valid accept tables else 0 if error
398 static bool verify_accept(struct aa_dfa
*dfa
, int flags
)
402 /* verify accept permissions */
403 for (i
= 0; i
< dfa
->tables
[YYTD_ID_ACCEPT
]->td_lolen
; i
++) {
404 int mode
= ACCEPT_TABLE(dfa
)[i
];
406 if (mode
& ~DFA_VALID_PERM_MASK
)
409 if (ACCEPT_TABLE2(dfa
)[i
] & ~DFA_VALID_PERM2_MASK
)
416 * unpack_dfa - unpack a file rule dfa
417 * @e: serialized data extent information (NOT NULL)
419 * returns dfa or ERR_PTR or NULL if no dfa
421 static struct aa_dfa
*unpack_dfa(struct aa_ext
*e
)
425 struct aa_dfa
*dfa
= NULL
;
427 size
= unpack_blob(e
, &blob
, "aadfa");
430 * The dfa is aligned with in the blob to 8 bytes
431 * from the beginning of the stream.
432 * alignment adjust needed by dfa unpack
434 size_t sz
= blob
- (char *) e
->start
-
435 ((e
->pos
- e
->start
) & 7);
436 size_t pad
= ALIGN(sz
, 8) - sz
;
437 int flags
= TO_ACCEPT1_FLAG(YYTD_DATA32
) |
438 TO_ACCEPT2_FLAG(YYTD_DATA32
) | DFA_FLAG_VERIFY_STATES
;
439 dfa
= aa_dfa_unpack(blob
+ pad
, size
- pad
, flags
);
444 if (!verify_accept(dfa
, flags
))
452 return ERR_PTR(-EPROTO
);
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)
460 * Returns: 1 if table successfully unpacked
462 static bool unpack_trans_table(struct aa_ext
*e
, struct aa_profile
*profile
)
464 void *saved_pos
= e
->pos
;
466 /* exec table is optional */
467 if (unpack_nameX(e
, AA_STRUCT
, "xtable")) {
470 size
= unpack_array(e
, NULL
);
471 /* currently 4 exec bits and entries 0-3 are reserved iupcx */
474 profile
->file
.trans
.table
= kzalloc(sizeof(char *) * size
,
476 if (!profile
->file
.trans
.table
)
479 profile
->file
.trans
.size
= size
;
480 for (i
= 0; i
< size
; i
++) {
482 int c
, j
, pos
, size2
= unpack_strdup(e
, &str
, NULL
);
483 /* unpack_strdup verifies that the last character is
484 * null termination byte.
488 profile
->file
.trans
.table
[i
] = str
;
489 /* verify that name doesn't start with space */
493 /* count internal # of internal \0 */
494 for (c
= j
= 0; j
< size2
- 1; j
++) {
501 /* first character after : must be valid */
504 /* beginning with : requires an embedded \0,
505 * verify that exactly 1 internal \0 exists
506 * trailing \0 already verified by unpack_strdup
508 * convert \0 back to : for label_parse
515 /* fail - all other cases with embedded \0 */
518 if (!unpack_nameX(e
, AA_ARRAYEND
, NULL
))
520 if (!unpack_nameX(e
, AA_STRUCTEND
, NULL
))
526 aa_free_domain_entries(&profile
->file
.trans
);
531 static bool unpack_rlimits(struct aa_ext
*e
, struct aa_profile
*profile
)
535 /* rlimits are optional */
536 if (unpack_nameX(e
, AA_STRUCT
, "rlimits")) {
539 if (!unpack_u32(e
, &tmp
, NULL
))
541 profile
->rlimits
.mask
= tmp
;
543 size
= unpack_array(e
, NULL
);
544 if (size
> RLIM_NLIMITS
)
546 for (i
= 0; i
< size
; i
++) {
548 int a
= aa_map_resource(i
);
549 if (!unpack_u64(e
, &tmp2
, NULL
))
551 profile
->rlimits
.limits
[a
].rlim_max
= tmp2
;
553 if (!unpack_nameX(e
, AA_ARRAYEND
, NULL
))
555 if (!unpack_nameX(e
, AA_STRUCTEND
, NULL
))
565 static void *kvmemdup(const void *src
, size_t len
)
567 void *p
= kvmalloc(len
, GFP_KERNEL
);
574 static u32
strhash(const void *data
, u32 len
, u32 seed
)
576 const char * const *key
= data
;
578 return jhash(*key
, strlen(*key
), seed
);
581 static int datacmp(struct rhashtable_compare_arg
*arg
, const void *obj
)
583 const struct aa_data
*data
= obj
;
584 const char * const *key
= arg
->key
;
586 return strcmp(data
->key
, *key
);
590 * unpack_profile - unpack a serialized profile
591 * @e: serialized data extent information (NOT NULL)
593 * NOTE: unpack profile sets audit struct if there is a failure
595 static struct aa_profile
*unpack_profile(struct aa_ext
*e
, char **ns_name
)
597 struct aa_profile
*profile
= NULL
;
598 const char *tmpname
, *tmpns
= NULL
, *name
= NULL
;
599 const char *info
= "failed to unpack profile";
600 size_t size
= 0, ns_len
;
601 struct rhashtable_params params
= { 0 };
603 struct aa_data
*data
;
604 int i
, error
= -EPROTO
;
610 /* check that we have the right struct being passed */
611 if (!unpack_nameX(e
, AA_STRUCT
, "profile"))
613 if (!unpack_str(e
, &name
, NULL
))
618 tmpname
= aa_splitn_fqname(name
, strlen(name
), &tmpns
, &ns_len
);
620 *ns_name
= kstrndup(tmpns
, ns_len
, GFP_KERNEL
);
622 info
= "out of memory";
628 profile
= aa_alloc_profile(name
, NULL
, GFP_KERNEL
);
630 return ERR_PTR(-ENOMEM
);
632 /* profile renaming is optional */
633 (void) unpack_str(e
, &profile
->rename
, "rename");
635 /* attachment string is optional */
636 (void) unpack_str(e
, &profile
->attach
, "attach");
638 /* 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
;
646 /* xmatch_len is not optional if xmatch is set */
647 if (profile
->xmatch
) {
648 if (!unpack_u32(e
, &tmp
, NULL
)) {
649 info
= "missing xmatch len";
652 profile
->xmatch_len
= tmp
;
655 /* disconnected attachment string is optional */
656 (void) unpack_str(e
, &profile
->disconnected
, "disconnected");
658 /* per profile debug flags (complain, audit) */
659 if (!unpack_nameX(e
, AA_STRUCT
, "flags")) {
660 info
= "profile missing flags";
663 info
= "failed to unpack profile flags";
664 if (!unpack_u32(e
, &tmp
, NULL
))
666 if (tmp
& PACKED_FLAG_HAT
)
667 profile
->label
.flags
|= FLAG_HAT
;
668 if (!unpack_u32(e
, &tmp
, NULL
))
670 if (tmp
== PACKED_MODE_COMPLAIN
|| (e
->version
& FORCE_COMPLAIN_FLAG
))
671 profile
->mode
= APPARMOR_COMPLAIN
;
672 else if (tmp
== PACKED_MODE_KILL
)
673 profile
->mode
= APPARMOR_KILL
;
674 else if (tmp
== PACKED_MODE_UNCONFINED
)
675 profile
->mode
= APPARMOR_UNCONFINED
;
676 if (!unpack_u32(e
, &tmp
, NULL
))
679 profile
->audit
= AUDIT_ALL
;
681 if (!unpack_nameX(e
, AA_STRUCTEND
, NULL
))
684 /* path_flags is optional */
685 if (unpack_u32(e
, &profile
->path_flags
, "path_flags"))
686 profile
->path_flags
|= profile
->label
.flags
&
687 PATH_MEDIATE_DELETED
;
689 /* set a default value if path_flags field is not present */
690 profile
->path_flags
= PATH_MEDIATE_DELETED
;
692 info
= "failed to unpack profile capabilities";
693 if (!unpack_u32(e
, &(profile
->caps
.allow
.cap
[0]), NULL
))
695 if (!unpack_u32(e
, &(profile
->caps
.audit
.cap
[0]), NULL
))
697 if (!unpack_u32(e
, &(profile
->caps
.quiet
.cap
[0]), NULL
))
699 if (!unpack_u32(e
, &tmpcap
.cap
[0], NULL
))
702 info
= "failed to unpack upper profile capabilities";
703 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
))
707 if (!unpack_u32(e
, &(profile
->caps
.audit
.cap
[1]), NULL
))
709 if (!unpack_u32(e
, &(profile
->caps
.quiet
.cap
[1]), NULL
))
711 if (!unpack_u32(e
, &(tmpcap
.cap
[1]), NULL
))
713 if (!unpack_nameX(e
, AA_STRUCTEND
, NULL
))
717 info
= "failed to unpack extended profile capabilities";
718 if (unpack_nameX(e
, AA_STRUCT
, "capsx")) {
719 /* optional extended caps mediation mask */
720 if (!unpack_u32(e
, &(profile
->caps
.extended
.cap
[0]), NULL
))
722 if (!unpack_u32(e
, &(profile
->caps
.extended
.cap
[1]), NULL
))
724 if (!unpack_nameX(e
, AA_STRUCTEND
, NULL
))
728 if (!unpack_rlimits(e
, profile
)) {
729 info
= "failed to unpack profile rlimits";
733 size
= unpack_array(e
, "net_allowed_af");
736 for (i
= 0; i
< size
; i
++) {
737 /* discard extraneous rules that this kernel will
743 if (!unpack_u16(e
, &tmp
, NULL
) ||
744 !unpack_u16(e
, &tmp
, NULL
) ||
745 !unpack_u16(e
, &tmp
, NULL
))
749 if (!unpack_u16(e
, &profile
->net
.allow
[i
], NULL
))
751 if (!unpack_u16(e
, &profile
->net
.audit
[i
], NULL
))
753 if (!unpack_u16(e
, &profile
->net
.quiet
[i
], NULL
))
756 if (!unpack_nameX(e
, AA_ARRAYEND
, NULL
))
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;
765 if (unpack_nameX(e
, AA_STRUCT
, "policydb")) {
766 /* generic policy dfa - optional and may be NULL */
767 info
= "failed to unpack policydb";
768 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
;
773 } else if (!profile
->policy
.dfa
) {
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],
787 if (!unpack_nameX(e
, AA_STRUCTEND
, NULL
))
790 profile
->policy
.dfa
= aa_get_dfa(nulldfa
);
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
;
797 info
= "failed to unpack profile file rules";
799 } 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
];
808 profile
->file
.dfa
= aa_get_dfa(nulldfa
);
810 if (!unpack_trans_table(e
, profile
)) {
811 info
= "failed to unpack profile transition table";
815 if (unpack_nameX(e
, AA_STRUCT
, "data")) {
816 info
= "out of memory";
817 profile
->data
= kzalloc(sizeof(*profile
->data
), GFP_KERNEL
);
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
;
828 if (rhashtable_init(profile
->data
, ¶ms
)) {
829 info
= "failed to init key, value hash table";
833 while (unpack_strdup(e
, &key
, NULL
)) {
834 data
= kzalloc(sizeof(*data
), GFP_KERNEL
);
841 data
->size
= unpack_blob(e
, &data
->data
, NULL
);
842 data
->data
= kvmemdup(data
->data
, data
->size
);
843 if (data
->size
&& !data
->data
) {
849 rhashtable_insert_fast(profile
->data
, &data
->head
,
853 if (!unpack_nameX(e
, AA_STRUCTEND
, NULL
)) {
854 info
= "failed to unpack end of key, value data table";
859 if (!unpack_nameX(e
, AA_STRUCTEND
, NULL
)) {
860 info
= "failed to unpack end of profile";
871 audit_iface(profile
, NULL
, name
, info
, e
, error
);
872 aa_free_profile(profile
);
874 return ERR_PTR(error
);
878 * verify_head - unpack serialized stream header
879 * @e: serialized data read head (NOT NULL)
880 * @required: whether the header is required or optional
881 * @ns: Returns - namespace if one is specified else NULL (NOT NULL)
883 * Returns: error or 0 if header is good
885 static int verify_header(struct aa_ext
*e
, int required
, const char **ns
)
887 int error
= -EPROTONOSUPPORT
;
888 const char *name
= NULL
;
891 /* get the interface version */
892 if (!unpack_u32(e
, &e
->version
, "version")) {
894 audit_iface(NULL
, NULL
, NULL
, "invalid profile format",
900 /* 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
904 if (VERSION_LT(e
->version
, v5
) || VERSION_GT(e
->version
, v7
)) {
905 audit_iface(NULL
, NULL
, NULL
, "unsupported interface version",
910 /* read the namespace if present */
911 if (unpack_str(e
, &name
, "namespace")) {
913 audit_iface(NULL
, NULL
, NULL
, "invalid namespace name",
917 if (*ns
&& strcmp(*ns
, name
))
918 audit_iface(NULL
, NULL
, NULL
, "invalid ns change", e
,
927 static bool verify_xindex(int xindex
, int table_size
)
930 xtype
= xindex
& AA_X_TYPE_MASK
;
931 index
= xindex
& AA_X_INDEX_MASK
;
932 if (xtype
== AA_X_TABLE
&& index
>= table_size
)
937 /* verify dfa xindexes are in range of transition tables */
938 static bool verify_dfa_xindex(struct aa_dfa
*dfa
, int table_size
)
941 for (i
= 0; i
< dfa
->tables
[YYTD_ID_ACCEPT
]->td_lolen
; i
++) {
942 if (!verify_xindex(dfa_user_xindex(dfa
, i
), table_size
))
944 if (!verify_xindex(dfa_other_xindex(dfa
, i
), table_size
))
951 * verify_profile - Do post unpack analysis to verify profile consistency
952 * @profile: profile to verify (NOT NULL)
954 * Returns: 0 if passes verification else error
956 static int verify_profile(struct aa_profile
*profile
)
958 if (profile
->file
.dfa
&&
959 !verify_dfa_xindex(profile
->file
.dfa
,
960 profile
->file
.trans
.size
)) {
961 audit_iface(profile
, NULL
, NULL
, "Invalid named transition",
969 void aa_load_ent_free(struct aa_load_ent
*ent
)
972 aa_put_profile(ent
->rename
);
973 aa_put_profile(ent
->old
);
974 aa_put_profile(ent
->new);
980 struct aa_load_ent
*aa_load_ent_alloc(void)
982 struct aa_load_ent
*ent
= kzalloc(sizeof(*ent
), GFP_KERNEL
);
984 INIT_LIST_HEAD(&ent
->list
);
989 * aa_unpack - unpack packed binary profile(s) data loaded from user space
990 * @udata: user data copied to kmem (NOT NULL)
991 * @lh: list to place unpacked profiles in a aa_repl_ws
992 * @ns: Returns namespace profile is in if specified else NULL (NOT NULL)
994 * 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
998 * Returns: profile(s) on @lh else error pointer if fails to unpack
1000 int aa_unpack(struct aa_loaddata
*udata
, struct list_head
*lh
,
1003 struct aa_load_ent
*tmp
, *ent
;
1004 struct aa_profile
*profile
= NULL
;
1007 .start
= udata
->data
,
1008 .end
= udata
->data
+ udata
->size
,
1013 while (e
.pos
< e
.end
) {
1014 char *ns_name
= NULL
;
1016 error
= verify_header(&e
, e
.pos
== e
.start
, ns
);
1021 profile
= unpack_profile(&e
, &ns_name
);
1022 if (IS_ERR(profile
)) {
1023 error
= PTR_ERR(profile
);
1027 error
= verify_profile(profile
);
1031 if (aa_g_hash_policy
)
1032 error
= aa_calc_profile_hash(profile
, e
.version
, start
,
1037 ent
= aa_load_ent_alloc();
1044 ent
->ns_name
= ns_name
;
1045 list_add_tail(&ent
->list
, lh
);
1047 udata
->abi
= e
.version
& K_ABI_MASK
;
1048 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
);
1059 aa_put_profile(profile
);
1062 list_for_each_entry_safe(ent
, tmp
, lh
, list
) {
1063 list_del_init(&ent
->list
);
1064 aa_load_ent_free(ent
);