mirror of
https://github.com/torvalds/linux.git
synced 2024-12-05 02:23:16 +00:00
250f2da49c
Syzkaller reported a OOB-read with the stacktrace below. This occurs
inside __aa_lookupn_ns as `n` is not initialized. `n` is obtained from
aa_splitn_fqname. In cases where `name` is invalid, aa_splitn_fqname
returns without initializing `ns_name` and `ns_len`.
Fix this by always initializing `ns_name` and `ns_len`.
__dump_stack lib/dump_stack.c:77 [inline]
dump_stack+0x1c4/0x2b4 lib/dump_stack.c:113
print_address_description.cold.8+0x9/0x1ff mm/kasan/report.c:256
kasan_report_error mm/kasan/report.c:354 [inline]
kasan_report.cold.9+0x242/0x309 mm/kasan/report.c:412
__asan_report_load1_noabort+0x14/0x20 mm/kasan/report.c:430
memcmp+0xe3/0x160 lib/string.c:861
strnstr+0x4b/0x70 lib/string.c:934
__aa_lookupn_ns+0xc1/0x570 security/apparmor/policy_ns.c:209
aa_lookupn_ns+0x88/0x1e0 security/apparmor/policy_ns.c:240
aa_fqlookupn_profile+0x1b9/0x1010 security/apparmor/policy.c:468
fqlookupn_profile+0x80/0xc0 security/apparmor/label.c:1844
aa_label_strn_parse+0xa3a/0x1230 security/apparmor/label.c:1908
aa_label_parse+0x42/0x50 security/apparmor/label.c:1943
aa_change_profile+0x513/0x3510 security/apparmor/domain.c:1362
apparmor_setprocattr+0xaa4/0x1150 security/apparmor/lsm.c:658
security_setprocattr+0x66/0xc0 security/security.c:1298
proc_pid_attr_write+0x301/0x540 fs/proc/base.c:2555
__vfs_write+0x119/0x9f0 fs/read_write.c:485
vfs_write+0x1fc/0x560 fs/read_write.c:549
ksys_write+0x101/0x260 fs/read_write.c:598
__do_sys_write fs/read_write.c:610 [inline]
__se_sys_write fs/read_write.c:607 [inline]
__x64_sys_write+0x73/0xb0 fs/read_write.c:607
do_syscall_64+0x1b9/0x820 arch/x86/entry/common.c:290
entry_SYSCALL_64_after_hwframe+0x49/0xbe
Fixes: 3b0aaf5866
("apparmor: add lib fn to find the "split" for fqnames")
Reported-by: syzbot+61e4b490d9d2da591b50@syzkaller.appspotmail.com
Signed-off-by: Zubin Mithra <zsm@chromium.org>
Reviewed-by: Kees Cook <keescook@chromium.org>
Signed-off-by: John Johansen <john.johansen@canonical.com>
530 lines
13 KiB
C
530 lines
13 KiB
C
/*
|
|
* AppArmor security module
|
|
*
|
|
* This file contains basic common functions used in AppArmor
|
|
*
|
|
* Copyright (C) 1998-2008 Novell/SUSE
|
|
* Copyright 2009-2010 Canonical Ltd.
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License as
|
|
* published by the Free Software Foundation, version 2 of the
|
|
* License.
|
|
*/
|
|
|
|
#include <linux/ctype.h>
|
|
#include <linux/mm.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/string.h>
|
|
#include <linux/vmalloc.h>
|
|
|
|
#include "include/audit.h"
|
|
#include "include/apparmor.h"
|
|
#include "include/lib.h"
|
|
#include "include/perms.h"
|
|
#include "include/policy.h"
|
|
|
|
struct aa_perms nullperms;
|
|
struct aa_perms allperms = { .allow = ALL_PERMS_MASK,
|
|
.quiet = ALL_PERMS_MASK,
|
|
.hide = ALL_PERMS_MASK };
|
|
|
|
/**
|
|
* aa_split_fqname - split a fqname into a profile and namespace name
|
|
* @fqname: a full qualified name in namespace profile format (NOT NULL)
|
|
* @ns_name: pointer to portion of the string containing the ns name (NOT NULL)
|
|
*
|
|
* Returns: profile name or NULL if one is not specified
|
|
*
|
|
* Split a namespace name from a profile name (see policy.c for naming
|
|
* description). If a portion of the name is missing it returns NULL for
|
|
* that portion.
|
|
*
|
|
* NOTE: may modify the @fqname string. The pointers returned point
|
|
* into the @fqname string.
|
|
*/
|
|
char *aa_split_fqname(char *fqname, char **ns_name)
|
|
{
|
|
char *name = strim(fqname);
|
|
|
|
*ns_name = NULL;
|
|
if (name[0] == ':') {
|
|
char *split = strchr(&name[1], ':');
|
|
*ns_name = skip_spaces(&name[1]);
|
|
if (split) {
|
|
/* overwrite ':' with \0 */
|
|
*split++ = 0;
|
|
if (strncmp(split, "//", 2) == 0)
|
|
split += 2;
|
|
name = skip_spaces(split);
|
|
} else
|
|
/* a ns name without a following profile is allowed */
|
|
name = NULL;
|
|
}
|
|
if (name && *name == 0)
|
|
name = NULL;
|
|
|
|
return name;
|
|
}
|
|
|
|
/**
|
|
* skipn_spaces - Removes leading whitespace from @str.
|
|
* @str: The string to be stripped.
|
|
*
|
|
* Returns a pointer to the first non-whitespace character in @str.
|
|
* if all whitespace will return NULL
|
|
*/
|
|
|
|
const char *skipn_spaces(const char *str, size_t n)
|
|
{
|
|
for (; n && isspace(*str); --n)
|
|
++str;
|
|
if (n)
|
|
return (char *)str;
|
|
return NULL;
|
|
}
|
|
|
|
const char *aa_splitn_fqname(const char *fqname, size_t n, const char **ns_name,
|
|
size_t *ns_len)
|
|
{
|
|
const char *end = fqname + n;
|
|
const char *name = skipn_spaces(fqname, n);
|
|
|
|
*ns_name = NULL;
|
|
*ns_len = 0;
|
|
|
|
if (!name)
|
|
return NULL;
|
|
|
|
if (name[0] == ':') {
|
|
char *split = strnchr(&name[1], end - &name[1], ':');
|
|
*ns_name = skipn_spaces(&name[1], end - &name[1]);
|
|
if (!*ns_name)
|
|
return NULL;
|
|
if (split) {
|
|
*ns_len = split - *ns_name;
|
|
if (*ns_len == 0)
|
|
*ns_name = NULL;
|
|
split++;
|
|
if (end - split > 1 && strncmp(split, "//", 2) == 0)
|
|
split += 2;
|
|
name = skipn_spaces(split, end - split);
|
|
} else {
|
|
/* a ns name without a following profile is allowed */
|
|
name = NULL;
|
|
*ns_len = end - *ns_name;
|
|
}
|
|
}
|
|
if (name && *name == 0)
|
|
name = NULL;
|
|
|
|
return name;
|
|
}
|
|
|
|
/**
|
|
* aa_info_message - log a none profile related status message
|
|
* @str: message to log
|
|
*/
|
|
void aa_info_message(const char *str)
|
|
{
|
|
if (audit_enabled) {
|
|
DEFINE_AUDIT_DATA(sa, LSM_AUDIT_DATA_NONE, NULL);
|
|
|
|
aad(&sa)->info = str;
|
|
aa_audit_msg(AUDIT_APPARMOR_STATUS, &sa, NULL);
|
|
}
|
|
printk(KERN_INFO "AppArmor: %s\n", str);
|
|
}
|
|
|
|
__counted char *aa_str_alloc(int size, gfp_t gfp)
|
|
{
|
|
struct counted_str *str;
|
|
|
|
str = kmalloc(sizeof(struct counted_str) + size, gfp);
|
|
if (!str)
|
|
return NULL;
|
|
|
|
kref_init(&str->count);
|
|
return str->name;
|
|
}
|
|
|
|
void aa_str_kref(struct kref *kref)
|
|
{
|
|
kfree(container_of(kref, struct counted_str, count));
|
|
}
|
|
|
|
|
|
const char aa_file_perm_chrs[] = "xwracd km l ";
|
|
const char *aa_file_perm_names[] = {
|
|
"exec",
|
|
"write",
|
|
"read",
|
|
"append",
|
|
|
|
"create",
|
|
"delete",
|
|
"open",
|
|
"rename",
|
|
|
|
"setattr",
|
|
"getattr",
|
|
"setcred",
|
|
"getcred",
|
|
|
|
"chmod",
|
|
"chown",
|
|
"chgrp",
|
|
"lock",
|
|
|
|
"mmap",
|
|
"mprot",
|
|
"link",
|
|
"snapshot",
|
|
|
|
"unknown",
|
|
"unknown",
|
|
"unknown",
|
|
"unknown",
|
|
|
|
"unknown",
|
|
"unknown",
|
|
"unknown",
|
|
"unknown",
|
|
|
|
"stack",
|
|
"change_onexec",
|
|
"change_profile",
|
|
"change_hat",
|
|
};
|
|
|
|
/**
|
|
* aa_perm_mask_to_str - convert a perm mask to its short string
|
|
* @str: character buffer to store string in (at least 10 characters)
|
|
* @str_size: size of the @str buffer
|
|
* @chrs: NUL-terminated character buffer of permission characters
|
|
* @mask: permission mask to convert
|
|
*/
|
|
void aa_perm_mask_to_str(char *str, size_t str_size, const char *chrs, u32 mask)
|
|
{
|
|
unsigned int i, perm = 1;
|
|
size_t num_chrs = strlen(chrs);
|
|
|
|
for (i = 0; i < num_chrs; perm <<= 1, i++) {
|
|
if (mask & perm) {
|
|
/* Ensure that one byte is left for NUL-termination */
|
|
if (WARN_ON_ONCE(str_size <= 1))
|
|
break;
|
|
|
|
*str++ = chrs[i];
|
|
str_size--;
|
|
}
|
|
}
|
|
*str = '\0';
|
|
}
|
|
|
|
void aa_audit_perm_names(struct audit_buffer *ab, const char * const *names,
|
|
u32 mask)
|
|
{
|
|
const char *fmt = "%s";
|
|
unsigned int i, perm = 1;
|
|
bool prev = false;
|
|
|
|
for (i = 0; i < 32; perm <<= 1, i++) {
|
|
if (mask & perm) {
|
|
audit_log_format(ab, fmt, names[i]);
|
|
if (!prev) {
|
|
prev = true;
|
|
fmt = " %s";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void aa_audit_perm_mask(struct audit_buffer *ab, u32 mask, const char *chrs,
|
|
u32 chrsmask, const char * const *names, u32 namesmask)
|
|
{
|
|
char str[33];
|
|
|
|
audit_log_format(ab, "\"");
|
|
if ((mask & chrsmask) && chrs) {
|
|
aa_perm_mask_to_str(str, sizeof(str), chrs, mask & chrsmask);
|
|
mask &= ~chrsmask;
|
|
audit_log_format(ab, "%s", str);
|
|
if (mask & namesmask)
|
|
audit_log_format(ab, " ");
|
|
}
|
|
if ((mask & namesmask) && names)
|
|
aa_audit_perm_names(ab, names, mask & namesmask);
|
|
audit_log_format(ab, "\"");
|
|
}
|
|
|
|
/**
|
|
* aa_audit_perms_cb - generic callback fn for auditing perms
|
|
* @ab: audit buffer (NOT NULL)
|
|
* @va: audit struct to audit values of (NOT NULL)
|
|
*/
|
|
static void aa_audit_perms_cb(struct audit_buffer *ab, void *va)
|
|
{
|
|
struct common_audit_data *sa = va;
|
|
|
|
if (aad(sa)->request) {
|
|
audit_log_format(ab, " requested_mask=");
|
|
aa_audit_perm_mask(ab, aad(sa)->request, aa_file_perm_chrs,
|
|
PERMS_CHRS_MASK, aa_file_perm_names,
|
|
PERMS_NAMES_MASK);
|
|
}
|
|
if (aad(sa)->denied) {
|
|
audit_log_format(ab, "denied_mask=");
|
|
aa_audit_perm_mask(ab, aad(sa)->denied, aa_file_perm_chrs,
|
|
PERMS_CHRS_MASK, aa_file_perm_names,
|
|
PERMS_NAMES_MASK);
|
|
}
|
|
audit_log_format(ab, " peer=");
|
|
aa_label_xaudit(ab, labels_ns(aad(sa)->label), aad(sa)->peer,
|
|
FLAGS_NONE, GFP_ATOMIC);
|
|
}
|
|
|
|
/**
|
|
* aa_apply_modes_to_perms - apply namespace and profile flags to perms
|
|
* @profile: that perms where computed from
|
|
* @perms: perms to apply mode modifiers to
|
|
*
|
|
* TODO: split into profile and ns based flags for when accumulating perms
|
|
*/
|
|
void aa_apply_modes_to_perms(struct aa_profile *profile, struct aa_perms *perms)
|
|
{
|
|
switch (AUDIT_MODE(profile)) {
|
|
case AUDIT_ALL:
|
|
perms->audit = ALL_PERMS_MASK;
|
|
/* fall through */
|
|
case AUDIT_NOQUIET:
|
|
perms->quiet = 0;
|
|
break;
|
|
case AUDIT_QUIET:
|
|
perms->audit = 0;
|
|
/* fall through */
|
|
case AUDIT_QUIET_DENIED:
|
|
perms->quiet = ALL_PERMS_MASK;
|
|
break;
|
|
}
|
|
|
|
if (KILL_MODE(profile))
|
|
perms->kill = ALL_PERMS_MASK;
|
|
else if (COMPLAIN_MODE(profile))
|
|
perms->complain = ALL_PERMS_MASK;
|
|
/*
|
|
* TODO:
|
|
* else if (PROMPT_MODE(profile))
|
|
* perms->prompt = ALL_PERMS_MASK;
|
|
*/
|
|
}
|
|
|
|
static u32 map_other(u32 x)
|
|
{
|
|
return ((x & 0x3) << 8) | /* SETATTR/GETATTR */
|
|
((x & 0x1c) << 18) | /* ACCEPT/BIND/LISTEN */
|
|
((x & 0x60) << 19); /* SETOPT/GETOPT */
|
|
}
|
|
|
|
void aa_compute_perms(struct aa_dfa *dfa, unsigned int state,
|
|
struct aa_perms *perms)
|
|
{
|
|
*perms = (struct aa_perms) {
|
|
.allow = dfa_user_allow(dfa, state),
|
|
.audit = dfa_user_audit(dfa, state),
|
|
.quiet = dfa_user_quiet(dfa, state),
|
|
};
|
|
|
|
/* for v5 perm mapping in the policydb, the other set is used
|
|
* to extend the general perm set
|
|
*/
|
|
perms->allow |= map_other(dfa_other_allow(dfa, state));
|
|
perms->audit |= map_other(dfa_other_audit(dfa, state));
|
|
perms->quiet |= map_other(dfa_other_quiet(dfa, state));
|
|
// perms->xindex = dfa_user_xindex(dfa, state);
|
|
}
|
|
|
|
/**
|
|
* aa_perms_accum_raw - accumulate perms with out masking off overlapping perms
|
|
* @accum - perms struct to accumulate into
|
|
* @addend - perms struct to add to @accum
|
|
*/
|
|
void aa_perms_accum_raw(struct aa_perms *accum, struct aa_perms *addend)
|
|
{
|
|
accum->deny |= addend->deny;
|
|
accum->allow &= addend->allow & ~addend->deny;
|
|
accum->audit |= addend->audit & addend->allow;
|
|
accum->quiet &= addend->quiet & ~addend->allow;
|
|
accum->kill |= addend->kill & ~addend->allow;
|
|
accum->stop |= addend->stop & ~addend->allow;
|
|
accum->complain |= addend->complain & ~addend->allow & ~addend->deny;
|
|
accum->cond |= addend->cond & ~addend->allow & ~addend->deny;
|
|
accum->hide &= addend->hide & ~addend->allow;
|
|
accum->prompt |= addend->prompt & ~addend->allow & ~addend->deny;
|
|
}
|
|
|
|
/**
|
|
* aa_perms_accum - accumulate perms, masking off overlapping perms
|
|
* @accum - perms struct to accumulate into
|
|
* @addend - perms struct to add to @accum
|
|
*/
|
|
void aa_perms_accum(struct aa_perms *accum, struct aa_perms *addend)
|
|
{
|
|
accum->deny |= addend->deny;
|
|
accum->allow &= addend->allow & ~accum->deny;
|
|
accum->audit |= addend->audit & accum->allow;
|
|
accum->quiet &= addend->quiet & ~accum->allow;
|
|
accum->kill |= addend->kill & ~accum->allow;
|
|
accum->stop |= addend->stop & ~accum->allow;
|
|
accum->complain |= addend->complain & ~accum->allow & ~accum->deny;
|
|
accum->cond |= addend->cond & ~accum->allow & ~accum->deny;
|
|
accum->hide &= addend->hide & ~accum->allow;
|
|
accum->prompt |= addend->prompt & ~accum->allow & ~accum->deny;
|
|
}
|
|
|
|
void aa_profile_match_label(struct aa_profile *profile, struct aa_label *label,
|
|
int type, u32 request, struct aa_perms *perms)
|
|
{
|
|
/* TODO: doesn't yet handle extended types */
|
|
unsigned int state;
|
|
|
|
state = aa_dfa_next(profile->policy.dfa,
|
|
profile->policy.start[AA_CLASS_LABEL],
|
|
type);
|
|
aa_label_match(profile, label, state, false, request, perms);
|
|
}
|
|
|
|
|
|
/* currently unused */
|
|
int aa_profile_label_perm(struct aa_profile *profile, struct aa_profile *target,
|
|
u32 request, int type, u32 *deny,
|
|
struct common_audit_data *sa)
|
|
{
|
|
struct aa_perms perms;
|
|
|
|
aad(sa)->label = &profile->label;
|
|
aad(sa)->peer = &target->label;
|
|
aad(sa)->request = request;
|
|
|
|
aa_profile_match_label(profile, &target->label, type, request, &perms);
|
|
aa_apply_modes_to_perms(profile, &perms);
|
|
*deny |= request & perms.deny;
|
|
return aa_check_perms(profile, &perms, request, sa, aa_audit_perms_cb);
|
|
}
|
|
|
|
/**
|
|
* aa_check_perms - do audit mode selection based on perms set
|
|
* @profile: profile being checked
|
|
* @perms: perms computed for the request
|
|
* @request: requested perms
|
|
* @deny: Returns: explicit deny set
|
|
* @sa: initialized audit structure (MAY BE NULL if not auditing)
|
|
* @cb: callback fn for type specific fields (MAY BE NULL)
|
|
*
|
|
* Returns: 0 if permission else error code
|
|
*
|
|
* Note: profile audit modes need to be set before calling by setting the
|
|
* perm masks appropriately.
|
|
*
|
|
* If not auditing then complain mode is not enabled and the
|
|
* error code will indicate whether there was an explicit deny
|
|
* with a positive value.
|
|
*/
|
|
int aa_check_perms(struct aa_profile *profile, struct aa_perms *perms,
|
|
u32 request, struct common_audit_data *sa,
|
|
void (*cb)(struct audit_buffer *, void *))
|
|
{
|
|
int type, error;
|
|
u32 denied = request & (~perms->allow | perms->deny);
|
|
|
|
if (likely(!denied)) {
|
|
/* mask off perms that are not being force audited */
|
|
request &= perms->audit;
|
|
if (!request || !sa)
|
|
return 0;
|
|
|
|
type = AUDIT_APPARMOR_AUDIT;
|
|
error = 0;
|
|
} else {
|
|
error = -EACCES;
|
|
|
|
if (denied & perms->kill)
|
|
type = AUDIT_APPARMOR_KILL;
|
|
else if (denied == (denied & perms->complain))
|
|
type = AUDIT_APPARMOR_ALLOWED;
|
|
else
|
|
type = AUDIT_APPARMOR_DENIED;
|
|
|
|
if (denied == (denied & perms->hide))
|
|
error = -ENOENT;
|
|
|
|
denied &= ~perms->quiet;
|
|
if (!sa || !denied)
|
|
return error;
|
|
}
|
|
|
|
if (sa) {
|
|
aad(sa)->label = &profile->label;
|
|
aad(sa)->request = request;
|
|
aad(sa)->denied = denied;
|
|
aad(sa)->error = error;
|
|
aa_audit_msg(type, sa, cb);
|
|
}
|
|
|
|
if (type == AUDIT_APPARMOR_ALLOWED)
|
|
error = 0;
|
|
|
|
return error;
|
|
}
|
|
|
|
|
|
/**
|
|
* aa_policy_init - initialize a policy structure
|
|
* @policy: policy to initialize (NOT NULL)
|
|
* @prefix: prefix name if any is required. (MAYBE NULL)
|
|
* @name: name of the policy, init will make a copy of it (NOT NULL)
|
|
* @gfp: allocation mode
|
|
*
|
|
* Note: this fn creates a copy of strings passed in
|
|
*
|
|
* Returns: true if policy init successful
|
|
*/
|
|
bool aa_policy_init(struct aa_policy *policy, const char *prefix,
|
|
const char *name, gfp_t gfp)
|
|
{
|
|
char *hname;
|
|
|
|
/* freed by policy_free */
|
|
if (prefix) {
|
|
hname = aa_str_alloc(strlen(prefix) + strlen(name) + 3, gfp);
|
|
if (hname)
|
|
sprintf(hname, "%s//%s", prefix, name);
|
|
} else {
|
|
hname = aa_str_alloc(strlen(name) + 1, gfp);
|
|
if (hname)
|
|
strcpy(hname, name);
|
|
}
|
|
if (!hname)
|
|
return false;
|
|
policy->hname = hname;
|
|
/* base.name is a substring of fqname */
|
|
policy->name = basename(policy->hname);
|
|
INIT_LIST_HEAD(&policy->list);
|
|
INIT_LIST_HEAD(&policy->profiles);
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* aa_policy_destroy - free the elements referenced by @policy
|
|
* @policy: policy that is to have its elements freed (NOT NULL)
|
|
*/
|
|
void aa_policy_destroy(struct aa_policy *policy)
|
|
{
|
|
AA_BUG(on_list_rcu(&policy->profiles));
|
|
AA_BUG(on_list_rcu(&policy->list));
|
|
|
|
/* don't free name as its a subset of hname */
|
|
aa_put_str(policy->hname);
|
|
}
|