mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
synced 2026-09-10 13:28:57 -04:00
3f4ae5fab6
AppArmor's begin_current_label_crit_section() is a scary function called
from lots of LSM hooks (in particular VFS/socket-related ones) that checks
if the label referenced by the current creds is marked FLAG_STALE, and if
so, attempts to use aa_replace_current_label() to replace the creds with an
updated version that uses a new label.
The first problem with this is that it would directly lead to UAF of
`struct cred` if anything in the kernel takes a pointer to the current
creds and accesses these past a security hook invocation that replaces
creds, like so:
```
const struct cred *cred = current_cred();
alloc_file_pseudo(...);
uid_t uid = cred->euid;
```
I don't know if anything in the kernel actually does this, but I think it
is very surprising that this pattern could lead to UAF.
The second problem is that things go wrong when aa_replace_current_label()
runs with overridden credentials. aa_replace_current_label() bails out if
`current_cred() != current_real_cred()` (mirroring the check in
proc_pid_attr_write()), but this check can't actually reliably detect
overridden credentials because the overridden creds can be the same as the
objective creds.
So in approximately the following scenario, things go wrong:
1. task begins with <creds A> (as both objective and subjective creds),
with refcount=2
2. task grabs an extra reference on <creds A> for overriding
3. task calls override_creds(<creds A>), which returns a pointer to the old
subjective creds (<creds A>)
4. task enters AppArmor LSM hook
5. AppArmor checks that objective/subjective creds are equal
6. AppArmor replaces both cred pointers with <creds B> and drops 2 refs on
<creds A>
7. task leaves AppArmor LSM hook
8. task calls revert_creds(<creds A>)
9. now task->cred is <creds A> while task->real_cred is <creds B>, but the
task_struct logically holds two references to <creds B>
10. another task drops the extra reference on <creds A> that was used for
overriding, refcount drops to 0
11. now task->real_cred points to freed creds
At this point, any access to current_cred() will be UAF.
I have a test case where I run aa-disable on a profile while a process
using that profile is blocked on splice() from a FUSE passthrough file into
a full pipe; after the profile update, the pipe becomes empty, splice()
resumes, the credentials go out of sync, and a subsequent getuid() syscall
results in a KASAN UAF splat.
To fix this, instead of directly replacing creds, do it via task_work that
will run at the end of the current syscall. (The point in time at which the
cred replacement happens should have no correctness impact; it is just a
performance optimization to avoid unnecessarily touching the refcount of
the new label.)
Note that AppArmor still performs direct cred replacements in the
sb_pivotroot LSM hook after this change, and that direct cred replacements
can still happen in VFS ->write() callbacks via proc_pid_attr_write().
There are two options for what to do with aa_dup_task_ctx(): Either
explicitly reset new->label_replacement_pending after the entire
aa_task_ctx has been copied, or switch to manually copying members over.
I am switching to manually copying members over because that should make
bugs more obvious.
Cc: stable@vger.kernel.org
Fixes: c75afcd153 ("AppArmor: contexts used in attaching policy to system objects")
Signed-off-by: Jann Horn <jannh@google.com>
Signed-off-by: John Johansen <john.johansen@canonical.com>
118 lines
3.3 KiB
C
118 lines
3.3 KiB
C
/* SPDX-License-Identifier: GPL-2.0-only */
|
|
/*
|
|
* AppArmor security module
|
|
*
|
|
* This file contains AppArmor task related definitions and mediation
|
|
*
|
|
* Copyright 2017 Canonical Ltd.
|
|
*/
|
|
|
|
#ifndef __AA_TASK_H
|
|
#define __AA_TASK_H
|
|
|
|
#include <linux/sched.h>
|
|
|
|
#include "audit.h"
|
|
#include "label.h"
|
|
|
|
static inline struct aa_task_ctx *task_ctx(struct task_struct *task)
|
|
{
|
|
return task->security + apparmor_blob_sizes.lbs_task;
|
|
}
|
|
|
|
/*
|
|
* struct aa_task_ctx - information for current task label change
|
|
* @nnp: snapshot of label at time of no_new_privs
|
|
* @onexec: profile to transition to on next exec (MAY BE NULL)
|
|
* @previous: profile the task may return to (MAY BE NULL)
|
|
* @token: magic value the task must know for returning to @previous_profile
|
|
* @label_replacement_tw: for aa_schedule_stale_label_replacement()
|
|
* @label_replacement_pending: is @label_replacement_tw pending?
|
|
*
|
|
* When changing this, check if aa_dup_task_ctx() needs to be updated.
|
|
*/
|
|
struct aa_task_ctx {
|
|
struct aa_label *nnp;
|
|
struct aa_label *onexec;
|
|
struct aa_label *previous;
|
|
u64 token;
|
|
struct callback_head label_replacement_tw;
|
|
bool label_replacement_pending;
|
|
};
|
|
|
|
int aa_replace_current_label(struct aa_label *label);
|
|
void aa_schedule_stale_label_replacement(void);
|
|
void aa_set_current_onexec(struct aa_label *label, bool stack);
|
|
int aa_set_current_hat(struct aa_label *label, u64 token);
|
|
int aa_restore_previous_label(u64 cookie);
|
|
struct aa_label *aa_get_task_label(struct task_struct *task);
|
|
|
|
/**
|
|
* aa_free_task_ctx - free a task_ctx
|
|
* @ctx: task_ctx to free (MAYBE NULL)
|
|
*/
|
|
static inline void aa_free_task_ctx(struct aa_task_ctx *ctx)
|
|
{
|
|
if (ctx) {
|
|
aa_put_label(ctx->nnp);
|
|
aa_put_label(ctx->previous);
|
|
aa_put_label(ctx->onexec);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* aa_dup_task_ctx - duplicate a task context, incrementing reference counts
|
|
* @new: a blank task context (NOT NULL)
|
|
* @old: the task context to copy (NOT NULL)
|
|
*/
|
|
static inline void aa_dup_task_ctx(struct aa_task_ctx *new,
|
|
const struct aa_task_ctx *old)
|
|
{
|
|
new->nnp = aa_get_label(old->nnp);
|
|
new->onexec = aa_get_label(old->onexec);
|
|
new->previous = aa_get_label(old->previous);
|
|
new->token = old->token;
|
|
}
|
|
|
|
/**
|
|
* aa_clear_task_ctx_trans - clear transition tracking info from the ctx
|
|
* @ctx: task context to clear (NOT NULL)
|
|
*/
|
|
static inline void aa_clear_task_ctx_trans(struct aa_task_ctx *ctx)
|
|
{
|
|
AA_BUG(!ctx);
|
|
|
|
aa_put_label(ctx->previous);
|
|
aa_put_label(ctx->onexec);
|
|
ctx->previous = NULL;
|
|
ctx->onexec = NULL;
|
|
ctx->token = 0;
|
|
}
|
|
|
|
#define AA_PTRACE_TRACE MAY_WRITE
|
|
#define AA_PTRACE_READ MAY_READ
|
|
#define AA_MAY_BE_TRACED AA_MAY_APPEND
|
|
#define AA_MAY_BE_READ AA_MAY_CREATE
|
|
#define PTRACE_PERM_SHIFT 2
|
|
|
|
#define AA_PTRACE_PERM_MASK (AA_PTRACE_READ | AA_PTRACE_TRACE | \
|
|
AA_MAY_BE_READ | AA_MAY_BE_TRACED)
|
|
#define AA_SIGNAL_PERM_MASK (MAY_READ | MAY_WRITE)
|
|
|
|
#define AA_SFS_SIG_MASK "hup int quit ill trap abrt bus fpe kill usr1 " \
|
|
"segv usr2 pipe alrm term stkflt chld cont stop stp ttin ttou urg " \
|
|
"xcpu xfsz vtalrm prof winch io pwr sys emt lost"
|
|
|
|
int aa_may_ptrace(const struct cred *tracer_cred, struct aa_label *tracer,
|
|
const struct cred *tracee_cred, struct aa_label *tracee,
|
|
u32 request);
|
|
|
|
|
|
|
|
#define AA_USERNS_CREATE 8
|
|
|
|
int aa_profile_ns_perm(struct aa_profile *profile,
|
|
struct apparmor_audit_data *ad, u32 request);
|
|
|
|
#endif /* __AA_TASK_H */
|