github-mirror/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-11-06 21:58:01 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity Graph

coredump: parse a snapshot of core_pattern

Browse Source 
This is a long-standing problem that I discussed a while back with Jann.
I didn't care enough about it to really fix it and it's from the
before-fore-times.

coredump_parse() reads core_pattern directly while it can concurrently
be modified. So it reads the first byte, figures out what mode is
wanted, then allocates the number buffer and then consumes the rest of
the core_pattern string.

Say the sysctl handler updates the core_pattern array byte by byte
(idiotic but supported). So that can lead to all kinds of insane mixups.
Say you could transform the old "|/usr/bin/helper" and the new
"/tmp/core.%p" into a usermodehelper started as "tmp/core.<pid>".

So copy what proc_do_uts_string() does and let the handler run
proc_dostring() on a copy, validate the copy and make it visible beneath
a spinlock. Then coredump_parse() can take a snapshot under the same
spinlock and parse a stable copy.

From now on, rejected patterns are never visible and we can drop the
whole rollback logic. It has the same minor defect that utsname has,
namely that two writers can race on a non-zero offset. Irrelevant imho.

Reviewed-by: Oleg Nesterov <oleg@redhat.com>
Link: https://patch.msgid.link/20260921-work-coredump-fixes-v3-3-8e4adb1619e6@kernel.org
Signed-off-by: Christian Brauner (Amutable) <brauner@kernel.org>
This commit is contained in:
Christian Brauner 2026-09-21 15:44:52 +02:00
parent 852d7eaa44
commit 8421a62085
No known key found for this signature in database
GPG Key ID: 91C61BC06578DCA2
1 changed files with 37 additions and 22 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

59
fs/coredump.c
View File

@ -84,6 +84,8 @@ static int core_uses_pid;
static unsigned int core_pipe_limit;
static unsigned int core_sort_vma;
static char core_pattern[CORENAME_MAX_SIZE] = "core";
/* Taken around every copy in and out of core_pattern. */
static DEFINE_SPINLOCK(core_pattern_lock);
static int core_name_size = CORENAME_MAX_SIZE;
unsigned int core_file_note_size_limit = CORE_FILE_NOTE_SIZE_DEFAULT;
static atomic_t core_pipe_count = ATOMIC_INIT(0);
@ -239,11 +241,16 @@ static bool coredump_parse(struct core_name *cn, struct coredump_params *cprm,
size_t **argv, int *argc)
{
const struct cred *cred = current_cred();
const char *pat_ptr = core_pattern;
char pattern[CORENAME_MAX_SIZE];
const char *pat_ptr = pattern;
bool was_space = false;
int pid_in_pattern = 0;
int err = 0;
/* The sysctl handler may be publishing a new pattern. */
scoped_guard(spinlock, &core_pattern_lock)
strscpy(pattern, core_pattern);
cprm->mask = COREDUMP_KERNEL;
if (core_pipe_limit)
cprm->mask |= COREDUMP_WAIT;
@ -1640,11 +1647,11 @@ void validate_coredump_safety(void)
}
}
static inline bool check_coredump_socket(void)
static inline bool check_coredump_socket(const char *pattern)
{
const char *p;
if (core_pattern[0] != '@')
if (pattern[0] != '@')
return true;
/*
@ -1656,16 +1663,16 @@ static inline bool check_coredump_socket(void)
return false;
/* Must be an absolute path... */
if (core_pattern[1] != '/') {
if (pattern[1] != '/') {
/* ... or the socket request protocol... */
if (core_pattern[1] != '@')
if (pattern[1] != '@')
return false;
/* ... and if so must be an absolute path. */
if (core_pattern[2] != '/')
if (pattern[2] != '/')
return false;
p = &core_pattern[2];
p = &pattern[2];
} else {
p = &core_pattern[1];
p = &pattern[1];
}
/* The path obviously cannot exceed UNIX_PATH_MAX. */
@ -1673,7 +1680,7 @@ static inline bool check_coredump_socket(void)
return false;
/* Must not contain ".." in the path. */
if (name_contains_dotdot(core_pattern))
if (name_contains_dotdot(pattern))
return false;
return true;
@ -1682,27 +1689,35 @@ static inline bool check_coredump_socket(void)
static int proc_dostring_coredump(const struct ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos)
{
char pattern[CORENAME_MAX_SIZE];
const struct ctl_table tmp = {
.procname = table->procname,
.data = pattern,
.maxlen = sizeof(pattern),
};
bool changed = false;
int error;
ssize_t retval;
char old_core_pattern[CORENAME_MAX_SIZE];
if (!write)
return proc_dostring(table, write, buffer, lenp, ppos);
/* Work on a copy, proc_dostring() appends at *ppos. */
scoped_guard(spinlock, &core_pattern_lock)
strscpy(pattern, core_pattern);
retval = strscpy(old_core_pattern, core_pattern, CORENAME_MAX_SIZE);
error = proc_dostring(table, write, buffer, lenp, ppos);
if (error)
error = proc_dostring(&tmp, write, buffer, lenp, ppos);
if (error || !write)
return error;
if (!check_coredump_socket()) {
strscpy(core_pattern, old_core_pattern, retval + 1);
if (!check_coredump_socket(pattern))
return -EINVAL;
}
if (strncmp(old_core_pattern, core_pattern, CORENAME_MAX_SIZE))
/* Publish the validated pattern whole. */
scoped_guard(spinlock, &core_pattern_lock) {
changed = strncmp(pattern, core_pattern, CORENAME_MAX_SIZE);
if (changed)
strscpy(core_pattern, pattern);
}
if (changed)
validate_coredump_safety();
return error;
return 0;
}
static const unsigned int core_file_note_size_min = CORE_FILE_NOTE_SIZE_DEFAULT;